T + F + T

1<2 & 2<3

w <- sample( x=v , size=40, replace=TRUE)
#Quel est l'indice du dernier élément négatif de w ?
#l'indice du dernier élément, c'est le plus grand
max( which( w<0) )
w[w<0] <- -q
#Combien de fois le 1er élément de w est-il présent ?
sum(w == w[1] ou length( which (w == w[1]) )
v2 <-seq(from=10, to=1, by=(-1))
v3 <- (1:50)*2
head(v3) # Afficher uniquement le début du vecteur v3
v4[15] <- 105 # rj[365] <- "lu" 15 est l’indice qui n’existe pas encore dans le vecteur
vn <- rep( x= 1:20 , each= 100) v5 <- rep(x=(1:9) , times=10)
sqrt(v4) exp(v4)
# Calculer la somme 1/1^2 + 1/2^2 + ... + 1/20^2
sum((1/seq(from=1, to = 20, by = 1)**2))
paste0(“test”, 1:20)
sd(temp)
var(temp)
mean(temp)
median(temp)
min(temp)
max(temp)
summary(temp)
# affecter nommois aux names du vecteur temp
nommois <-c("jan", "fév" , "mar" , "avr" , "mai" , "jun" , "jul" , "aoû" , "sep" ,
"oct" , "nov" , "déc")
names(temp) <- nommois

Dataframe
dfteam <- data.frame(Age, Height, Weight, Sex, row.names = Noms)
dfteam[ 1:4 , ] #faire apparaître ligne 1 à 4 d’un dataframe ou:
dfteam[ c("Alex","Lilly", "Marc", "Olivier")] ou dfteam[ , c("Age", "Height", "Weight") ]
dfteam[Age,]
#Ajouter Colonne ou ligne
membre1 <- data.frame (Age=36, Height=158, Weight=47, Sex="F", row.names="Claire")
dfteam <- rbind(dfteam, membre1) # ou cbind pour les lignes
dfteam[, "Working" ] <- c("YES","NO","NO", "YES", "YES", "NO", "YES", "NO")
dfteam$WORKINGBIS <- c("YES","NO","NO", "YES", "YES", "NO", "YES", "NO")

#Supprimer colonne ou ligne

dfteam$WORKINGBIS <- NULL
#Extraire catégorie
dfg <- dfteam[ dfteam$Sex != "F", ]

Matrix
M<- matrix(data=c(-1,8,2,6,-9,12,-9,-5,1),byrow= T, ncol = 3) “byrow=booléen à TRUE pour
#signaler que les coefficients sont alignés en lignes
# créer la matrice N de taille 4x4 de coefficients a(i,j)=100/(i+j)
a<-function(i,j){100/(i+j)}
N<-outer(1:4, 1:4, a)
det(N)
P<-solve(N) #inverse matrice
P%*%N
# Remplacer tous les coefficients de D dont la valeur absolue est inférieure à 1e-10 par 0
D[abs(D)<1e-10]<-0
mean(Q[1,])
M[1,]
n<-nrow(M)
# créer un vecteur ligne U avec 3 fois 1
U<- matrix(data=c(1,1,1), nrow=3)
I<-diag(rep(1,3))
A<- I- 1/n*U%*%t(U)
# calculer P la matrice centrée en colonnes de M par l'opération Q = A x M
Q <- A%*%M

Suite et For
Farenheit <- function ( Celcius) { Celcius*1.8 + 32 }
tempF <- Farenheit(Celcius = temp) #input du vecteur temps dans un autre vecteur pour créer un
vecteur tempsF
mbf<-function(x) {(exp(x)+exp(-x))/2}
mbf(x=0)
v7<-mbf(x=u)

#Calculer le vecteur des termes de la suite selon la formule vf(n)=(a^n-b^n)/√5 par 3

#méthodes.
a <- (1+sqrt(5))/2
b <- (1-sqrt(5))/2
vf1 <- ( a ** (1:20) - b ** (1:20) ) / sqrt(5) #ou fib <- function(n) { ( a**n - b**n ) /
sqrt(5) }
#ou
vf3 <- NULL
for(n in 1:20) { vf3[n] <- ( a**n - b**n ) / sqrt(5) }
#Calcul d’une suite à partir de premières valeurs :
vr <- c( 1 , 1 )
for( n in 3:20 ) { vr[n] <- vr[n-1] + vr[n-2] } #ici la diff avec le vert du dessus c qu’on
met des vecteur (avec crochet) dans la formule du vecteur

Liste
lj <- list()
for (i in 0:6 ) { lj[[ jr[i+1] ]] <- jr[ ( 0 : 6 + i ) %% 7 + 1] }
finmois <- c(31 , 28 , 31, 30 , 31 , 30, 31, 31, 30 , 31, 30, 31)
numj <- NULL
for(i in finmois) { numj <- c(numj, 1:i ) }

Conditions
if (t>10){ x<-x+2 y<-10} else if (5<=t & t<10){ x<-x+1 y<-5 }else { x<-x-1 y<-3}
while (s <= n)
s <- s + d[s]
# ggplot() +
ggplot()+ # trait X Y titre trait transparance
geom_line(mapping=aes(x=1:20,y=vf1, colour="suite générale" , size=2) , alpha= 0.3)+
geom_line(mapping=aes(x=1:20,y=vr , colour="suite récurrente" , size=3) , alpha= 0.3)+
geom_smooth((mapping=aes(x=1:20,y=vr , colour="suite récurrente" , size=3) , alpha= 0.3)+
scale_color_manual(values= c("red", "blue") )+ #couleurs des traits
theme_minimal()+ #arrière plan vide
scale_y_log10()+ #échelle logarithmique
xlab("titre des X") + ylab("Titre Y")

plot(1:T,S,pch="+")
qplot(x=1:12, y=temp,geom="line")+labs(title="2014 de
Montsouris",x="Mois",y="T°")+scale_x_discrete(limits=nommois)
plot(), boxplot(), barplot(), hist(), curve()

plot(w ~ z, data = dt,

type = "o", # type de tracé: points ("p"), lignes ("l"), les deux ("b" ou "o"), ...
col = "blue", # couleur, tapez `colours()` pour la liste complète
pch = 4, # type de symboles, un chiffre entre 0 et 25, tapez `?points`
cex = 0.5, # taille des symboles
lty = 3, # type de lignes, un chiffre entre 1 et 6
lwd = 1.2, # taille de lignes
xlim = c(-2.5, 2.5), # limites de l'axe des x
ylim = c(-1.5, 1.5), # limites de l'axe des y)
xlab = "La variable z", # titre pour l'axe des x
ylab = "Le sinus de z", # titre pour l'axe des y
main = "La fonction sinus entre -pi et pi" # titre général pour le graphique

plot(w ~ z, data = dt)

points(x = -3:3, y = c(-1, -0.7, 0.3, 0, -0.3, 0.7, 1), col = "blue", pch = 4)
lines(x = -3:3, c(-1, -0.7, 0.3, 0, -0.3, 0.7, 1), col = "red")
text(x = -3:3, y = c(-1, -0.7, 0.3, 0, -0.3, 0.7, 1) + 0.05, labels = c("a", "b", "c", "d", "e", "f", "g"))

Proba

pbinom(3, 10, 0.3) renvoie P(Y 6 3) avec Y comme dans l’item précédent.
qbinom(0.6,10,0.3) renvoie le plus petit entier k tel que P(Y 6 k) > 0, 6.
runif(10,0,20) renvoie 10 valeurs tirées selon la loi uniforme sur l’intervalle [0; 20].
pnorm(3) renvoie P(Z 6 3) ou` Z suit une N (0; 1). On peut également taper
pnorm(3,mean=0,sd=1) ou pnorm(3,0,1) ou encore pnorm(q=3,mean=0,sd=1)

Exam 2021 AR4

colnames(dfX)<- paste0("T", 1:20)
c1 <- complex(modulus=1, argument=r1)
# Q1(X)=(1-2.Re(c1).X + X^2)
# Q3(X)=(1-2.Re(c3).X + X^2)
library(polynom)
Q1 <- polynomial(coef = c(1,-2*rc1, 1) )
Q1
Q3 <- polynomial(coef = c( 1 , -2*rc3 , 1) ) # puissance croissante
Q3
#racines de Q et contrôler la présence de c1, c3 et leurs 2 conjugués complexes
polyroot(Q)

# ******************************************
# Processus autoregressif oscillant AR(p=4)
#
# Première partie
# ******************************************

# Un processus autorégressif d'ordre p,noté AR(p), est une suite définie par récurrence :
# X[n] = f1.X[n-1] + f2.X[n-2] + ... + fp.X[n-p]
# où f1,...,fp sont des nombres réels appelés les paramètres du processus
# Le terme processus désigne simplement que le rang n représente une dimension temporelle

# Un processus est oscillant son polynome caractéristique a toute ses racines de module égal à
1
# Nous allons calculer et tracer des processus oscillants

# Le polynome caractéristique du processus X[n]

# est défini à partir de ses paramètres par la formule :
# Q(X) = 1- f1.X - f2.X^2 - ... - fp.X^p

# **********************************************
# Familiarisation avec l'aléatoire
# **********************************************

# ---- Question 0 ----

# Afficher 5 nombres aléatoires uniformes entre -10 et 10
# Utiliser runif( n=5, min=-10, max=10 )

runif( n=5, min=-10, max=10 )

# ---- Question 2 ----

# Dans r1, tirer un nombre aléatoire entre 0 et 2.pi
# Utiliser le générateur aléatoire uniforme : runif(n=..., min=..., max=...)
# En R le nombre pi s'écrit pi

r1 <- runif( n=1, min=0, max=2*pi )

r1

# ---- Question 3 ----

# Dans c1, créer un nombre aléatoire complexe de module 1 et d'argument r1
# utiliser complex(modulus=..., argument=...)

c1 <- complex(modulus=1, argument=r1)

c1

# ---- Question 4 ----

# Dans rc1, extraire la partie réelle de c1.
# Utiliser Re(...)
rc1 <- Re(c1)
rc1

# ---- Question 5 ----

# Idem pour r3, c3 et rc3

r3 <- runif( n=1, min=0, max=2*pi )

r3
c3 <- complex(modulus=1, argument=r3)
c3
rc3 <- Re(c3)
rc3

# ---- Question 6 ----

# Si ce n'est déjà fait, installer et lier le package Polynom
# Dans les variables Q1 et Q3, créer les polynômes :
# Q1(X)=(1-2.Re(c1).X + X^2)
# Q3(X)=(1-2.Re(c3).X + X^2)

library(polynom)
Q1 <- polynomial(coef = c(1,-2*rc1, 1) )
Q1
Q3 <- polynomial(coef = c( 1 , -2*rc3 , 1) ) # puissance croissante
Q3

# ---- Question 7 ----

# Dans la variable Q, créer le polynome Q(X) = Q1(X).Q3(X)
# les opérations * / - + fonctionnent sur les polynomes du package Polynom

Q <- Q1 * Q3
Q

# ---- Question 8 ----

# Afficher les racines de Q
# et contrôler la présence de c1, c3 et leurs 2 conjugués complexes

polyroot(Q)

# ---- Question 9 ----

# Dans un vecteur vf, extraire les coefficients de -Q (l'opposé de Q)
# vf doit être de longeur 5
# Utiliser coef(...)

vf <- coef( -Q )
vf

# ---- Question 10 ----

# Retirer le premier coefficient de vf (celui qui vaut -1)
# vf doit être de longueur 4 et son dernier coeffcient est -1

vf <- vf[-1]
vf

# ******************************************************************
# Simulation de X1 à X100
# du processus de paramètre vf
# X[n] = vf[1].X[n-1] + vf[2].X[n-2] + vf[3].X[n-3] + vf[4].X[n-4]
# ******************************************************************

# ---- Question 11 ----

# Dans un vecteur vX tirer p=4 nombres entre 0 et 1

vX <- runif(p, 0, 1)
vX

# ---- Question 12 ----

# Dans w, calculer w <- vf[1].vX[4] + vf[2].vX[3] + vf[3].vX[2] + vf[4].vX[1]

w <- vf[1]*vX[4] + vf[2]*vX[3] + vf[3]*vX[2] + vf[4]*vX[1]

w

# ---- Question 13 ----

# Dans vX générer les termes de X[n] pour n=p+1 à 100 par récurrence :
# vX[n] <- vf[1].vX[n-1] + vf[2].vX[n-2] + vf[3].vX[n-3] + vf[4].vX[n-4]
# Les p premiers termes de vX ont déjà été générés

for (n in (p+1):100 ){
vX[n] <- vf[1]*vX[n-1] + vf[2]*vX[n-2] + vf[3]*vX[n-3] + vf[4]*vX[n-4]
}

# ---- Question 14 ----

# Tracer la courbe issue de vX
# Verticalement : vX
# Horizontalement : n de 1 à 100
# Avec les titres :
# - Principal : Suite AR(p=4)
# - pour Y : Xn
# - pour X : n

plot(x=1:100 , y=vX, type="l")

library(ggplot2)
ggplot()+
geom_line(mapping = aes(x=1:100,y=vX ))+
labs( title="Suite AR(p=4)" , x="n", y="X")

#**********************************************
# Tracé 20 trajectoires de X[1] ... X[100]
# - avec les même paramètres vf
# - mais pour des valeurs initiales aléatoires
#**********************************************

# Ces 20 trajectoires vont être écrites dans les 20 colonnes d'une même matrice

# ---- Question 15 ----

# Générer une matrice mX de 20 colonnes et 100 lignes remplie de 0

mX <- matrix(data=0, nrow= 100, ncol=20)

str(mX)

# ---- Question 16 ----

# pour chaque colonne k, avec k=1 à k=20 de mX, écrire :
# 1- aux lignes 1 à p : tirer p nombres aléatoires entre 0 et 1
# 2- aux lignes p+1 à 100 : générer les valeurs du processus X[n] dont les p premiers termes
sont les valeurs des lignes 1 à p de la même colonne k
# utiliser une structure for ( ... ) avec accolades pour englober les deux commandes :

(for k in 1;20) {
sample

for (k in 1:20) {
vX <- runif(p, 0, 1)
for (n in (p + 1):100) {
vX[n] <-
vf[1] * vX[n - 1] + vf[2] * vX[n - 2] + vf[3] * vX[n - 3] + vf[4] * vX[n -4]
}

mX[, k] <- vX
}

# ---- Question 17 ----

# À partir de mX créer une dataframe dfX

dfX <- data.frame(mX)

dfX

# ---- Question 18 ----

# Nommer les colonnes de df : T1, ... , T20
# Les noms des colonnes T1...T20 seront générés automatiquement à l'aide de paste0
df<- name.col(paste0(“T”, 1:20)),df)

colnames(dfX)<- paste0("T", 1:20)

dfX

# ---- Question 19 ----

# Sur un même graphe, tracer les trajectoires T1 et T2 issues de dfX
# Donner des légende "T1" et "T2" aux deux courbes
# et une coloration automatique

ggplot()+
geom_line(mapping = aes(x=1:100, y=dfX$T1, colour="T1"))+
geom_line(mapping = aes(x=1:100, y=dfX$T2, colour="T2"))

ggplot()+
geom_line(mapping=aes(x=1:100, y=dfX,colour = “T1”,))+

# **********************************************************************
# Tracer de T1 .. T20 par sérialisation
# Il s'agit de tracer les 20 trajectiors simultanémeent
# par une seule commande geom_line()
# Pour cela les trajectoires vont devoir être compilées en série sur une dataframe
# avec 3 champs : n, X[n], Légende
# Le dataframe sérialisé aura cette forne :
# n | Xn | Légende
# -------------------------
# 1 | X1 | T1
# 2 | X2 | T1
# ...
# 100 | X100 | T1
# 1 | X1 | T2
# 2 | X2 | T2
# ...
# 100 | X100 | T2
# ...
# 1 | X1 | T20
# 2 | X2 | T20
# ...
# 100 | X100 | T20
# **********************************************************************

# ---- Question 20 ----

# Créer un vecteur vNS qui répète 20 fois la même séquence :
#1..100 1..100 1..100 .... 1..100

vNS <- rep( x= 1:100, times = 20)

vNS
rep<- rep((1:100, 20)
# ---- Question 21 ----
# Créer un vecteur texte vLegendeS qui enchaîne les séquences
# T1 ... T1 T2 ... T2 ... T20 ... T20
# où T1 est répété 100 fois, T2 100 fois, ... T20 100 fois
# Commencer par créer un vecteur numérique 1 ... 1 2 ... 2 .... 20 ... 20 où chaque nombre est
répété 100 fois
# Utiliser rep( ... , each= ...)
# Puis créer vLegendeS en utilisant paste0

vn <- rep( x= 1:20 , each= 100)

vn
vLegendeS <- paste0("T", vn)
vLegendeS

# ---- Question 22 ----

# Créer un vecteur vXS qui enchaîne les valeurs des 20 colonnes de la matrice mX
# de la colonne k=1 à la colonne k=20
# mX[1,1] ... mX[100,1] mX[1,2] ... mX[100,2] ..... mX[1,20] ... mX[100,20]
# Démarche :
# - Commencer par initialiser vXS par la première colonne mX[1,1] ... mX[100,1]
# - Puis combiner vXS avec chacune des colonnes de k=2 jusqu'à k=20
# Utiliser for( ...)

vXS <- mX[,1]

for (k in 2:20){
vXS <- c(vXS, mX[,k])
}

vXS
# ---- Question 23 ----
# Créer la dataframe dfXS qui réunit les 3 vecteurs vNS, vXS et vLegendeS

dfXS <- data.frame(vNS, vXS, vLegendeS)

# ---- Question 24 ----

# Tracer les 20 courbes simultanément avec des couleur et légendes automatiques
# en utilisant dfXS :
# - sa variable vNS pour X
# - sa variable vXS pour Y
# - e
t sa variable cLegendeS pour valeur du paramètre color
# Ajouter les titres :
# - Temps pour X
# - Valeur pour Y

ggplot()+
geom_line(mapping = aes(x=dfXS$vNS, y=dfXS$vXS, colour=dfXS$vLegendeS))+
labs(x="Temps", y="Valeur")

read.csv(file, # File name or full path of the file

header = TRUE, # Whether to read the header or not
sep = ",", # Separator of the values
quote = "\"", # Quoting character
dec = ".", # Decimal point
fill = TRUE, # Whether to fill blacks or not
comment.char = "", # Character of the comments or empty string
encoding = "unknown", # Encoding of the file
...)

TP1
Simul1.R

Simul2.R
# Générateur pseudo-aléatoire uniforme
# Algorithme de Winchman-Hill, la méthode congruentielle

x <- c(3)
y <- c(23)
z <- c(53)

# partie décimale
for (i in 2:1000) {
x[i] <- (171* x[i-1]) %% 30269
y[i] <- (172* y[i-1]) %% 30307
z[i] <- (170* z[i-1]) %% 30323
}

u<- (x/30269 + y/30307 + z/30323) %% 1

# tracer la courbe des fréquences cumulées (fonction de répartition)

# utiliser plot( x=fonction) et ecdf(vector) la fonction de répartition empirique d'un vector
plot(ecdf(u[1:10]), col="blue") #representation graphique
plot(punif, add=TRUE, col="red") #superposition du graphique au précédent

ks.test(u, "punif")

Simul3.R
# Annuelle
v <- 0.1
r <- 0.15

# Maturité
M <- 151

# Exercice (Strike)
K <- 202

j1 <- as.Date("2021/01/01")
j2 <- as.Date("2021/06/01")
T <- as.integer(difftime(j2,j1,units = c("days")))

S0 <- 200
S <- c(S0 * (1 + r * 1/365.25 + v * rnorm(1,0, sqrt(1/365.25))) )

for (t in 2:T) {
S[t] <- S[t-1] * (1 + r * 1/365.25 + v * rnorm(1,0, sqrt(1/365.25)))
}

# bénéfice
payoff <- max(c(S[T]-K,0))
# actualisé
payoffA <- payoff / exp(r*T/365.25)

plot(1:T,S,pch="+")

# S + A : antithétique

result <- c()

for( n in 1:10000 ){
S0 <- 200
vol <- rnorm(1,0, sqrt(1/365.25))
S <- c(S0 * (1 + r * 1/365.25 + v * vol ) )
A <- c(S0 * (1 + r * 1/365.25 - v * vol ) )

for (t in 2:T) {
vol <- rnorm(1,0, sqrt(1/365.25))
S[t] <- S[t-1] * (1 + r * 1/365.25 + v * vol)
 A[t] <- A[t-1] * (1 + r * 1/365.25 - v * vol)
}

# bénéfice S
payoff <- max(c(S[T]-K,0))
# actualisé
payoffA <- payoff / exp(r*T/365.25)
result <- c(result, payoffA)

# bénéfice A
payoff <- max(c(A[T]-K,0))
# actualisé
payoffA <- payoff / exp(r*T/365.25)
result <- c(result, payoffA)
}

mean(result)

Simul4.R
df <- read.csv(file = "titre.csv", sep=";", dec=",")
df

# tirer 3 nombres aleatoires uniformes runif(...)

# et "normalisez"-les pour que leur somme fasse 1.
cf1 <- runif(3)
cf1
cf <- cf1/sum(cf1)
cf

#H <- df*t(cf)
M <- as.matrix(df)
M
diag(cf)
H <- M%*%diag(cf)
H
head(H)
P <- rowSums(H)
P
#
mean(P)
sd(P)

e <- c()
v <- c()
for (i in 1:50000){
cf1 <- runif(3)
cf <- cf1/sum(cf1)
H <- M%*%diag(cf)
ch <- rowSums(H)

e[i] <- mean(ch)

v[i] <- sd(ch)
}

# graphqiue par plot(..., pch=c(...) )

plot(v, e, pch = c("+"))
plot(x=e[1:6], y=rep(1,6), pch=c("+"))

# supprimer les points intérieur

retire <- c()

retire

#
he<- max(sort(e)[-1]-sort(e)[-length(e)])*2
hv<- max(sort(v)[-1]-sort(v)[-length(v)])*2

for (i in 1:length(e)) {
nr <- intersect(which(abs(e-e[i])<he) , which(abs(v-v[i])<hv) )
er <- e[nr]
vr <- v[nr]

h <- which(er>e[i])
b <- which(er<e[i])

d <- which(vr>v[i])
g <- which(vr<v[i])

hd <- intersect(h,d)
if (length(hd) == 0) { next }
hg <- intersect(h,g)
if (length(hg) == 0) { next }
bd <- intersect(b,d)
if (length(bd) == 0) { next }
bg <- intersect(b,g)
if (length(bg) == 0) { next }

if ( length(hd)>0 & length(hg)>0 & length(bd)>0 & length(bg)>0) { retire <- c( retire, i) }

e <- e[-retire]
v <- v[-retire]
plot(v, e, pch = c("+"))

Simul5.R
# https://www.youtube.com/watch?v=lLzUcJf3E60

d <- rep(1:6,each=4)
names(d) <- rep(c("P","C","T","K"), 6)
d
n <- length(d)

x <- NULL
for (k in 1:10000) {
d <- sample(d)
 # fixe, prédiction
s <- 1
while (s <= n)
s <- s + d[s]
f1 <- s-n #attention d[s] insuffisant alors paste0(names(d)[1], d[1])
# mais position OK car pas deux fois même carte

# random
s <- sample(1:6, size=1)
while (s <= n)
s <- s + d[s]
f <- s-n

x[k] <- f==f1

}

# proba estimation ponctuelle

mean(x)

# proba estimation par intervalle

prop.test(x= sum(x), n= length(x) )

# test à 93%
prop.test(x= sum(x), n= length(x) , p=0.93 , alternative="two.sided" )

TP2
# 1 - Maximisation et Surface 3D

# la fonction 2 arg
f <- function (x,y) { (5-x**2 -x) + (2-y**2-y/2) }

f(x=1,y=2)

f(x=0,y=0)

# la fonction vectorielle
fvect <- function (v) {
x<- v[1]
y<- v[2]
return ( (5-x**2 -x) + (2-y**2-y/2) )
}
str(fvect)

fvect( v= c( 1, 2) )

fvect( v=c( 0, 0 ) )

# matrice de points pour la surface

# échantillonne x, y
vx<- seq(from=-5,to=5,by=0.1)
vy<- seq(from=-5,to=5,by=0.1)
vx
vy

# calcul de f(x, y) pour tous les x croisés avec tous les y

# produit externe

Mz <- outer( X= vx, Y= vy , FUN = f)

str(Mz)

Mx <- outer( vx , vy , FUN = function(x,y) { x })

str(Mx)

My <- outer( vx , vy , FUN = function(x,y) { y })

str(My)

g<- plot_ly(x=Mx,y=My,z=Mz)
add_surface(g)

# bty = “b”, “b2”, “f”, “g”, “bl”, “bl2”, “u”, “n”

# Maximum

resultat <- optim(par=c(0,0) , fn = fvect , control= list(fnscale=-1) )

str(resultat)

# TP Modèle Linéaire

# Régression linéaire multiple

# source : http://www.sthda.com/english/articles/40-regression-analysis/168-multiple-linear-
regression-in-r/

# données du package datarium

library(datarium)

# verif Environment > Global Environment > Datarium

str(marketing)

# Combien de variables ? De quels types ?

# varibale à expliquer : sales

# variables régresseurs : youtubes

# classe formula

# sales = b0 + b1*youtube + b2*facebook + b3*newspaper

# formule est composé d'une nom de variable (ici sales suivi du tilde ~ pour dire "environ
égal") suivi des variables explicatives séparées d'un + dans le cas d'un modèle linéaire

f1 <- sales ~ youtube + facebook + newspaper

str(f1)

# coefficients du modèle linéaire

# qr methode : dans un problème Y~Xb , la factorisation X=QR où Q orthogonale (tQ.Q=I) et R
(triangulaire) amène à une solution Rb=tQ.Y
modele <- lm( formula = f1, data = marketing, method="qr")
summary(modele)

# trop gros
str(modele)

# Qualité du modèle et des régresseurs

# analyse plus fine des coefficients avec estimation et test de significativité
resume <- summary(modele)
str(resume)

# coeff détermination (validité > 0.5² = 0.7)

resume$r.squared

# analyse des coeff

resume$coefficients

# p-value = 4e colonne, conserver les coeff significatifs (si p-value(x) > 5%, on peut
considérer que Beta(x) est nul et que la variable n'est pas signifiactive dans le modèle)
# afficher les noms des variables significatives autres que '(intercept)'
resume$coefficient[,4]<0.05

varSi <- rownames(resume$coefficients)[resume$coefficient[,4]<0.05 &

rownames(resume$coefficients)!='(Intercept)']
varSi

# Modele restreint aux variables contributives

f3 = sales ~youtube + facebook

# nouvelle regression

modele2 <- lm( formula = f3, data = marketing, method="qr")

# analyse plus fine des coefficients avec estimation et test de significativité

resume2 <- summary(modele2)

# coeff détermination
resume2$r.squared

# analyse coeff
resume2$coefficients

# Prediction automatique
dfVar <- data.frame(youtube=c(1500), facebook=c(1000))
dfVar

model1 <- lm( formula = sales ~ youtube + facebook , data = marketing, method="qr")

predict( modele2 , newdata = dfVar)

# Prediction Manuelle
# Vecteur des coefficients
# Une société investit 1500$ dans youtube et 2300$ dans facebook, estimer ses ventes
vBeta <-modele2$coefficients
vBeta

vVar <- c('(Intercept)'=1, 'youtube'=1500, 'facebook'=1000)

vVar

estSales <- vVar %*% vBeta

estSales

# Régression linéaire simple

# Coefficients et prédiction
# sales = c0 + c1*(youtube + facebook + newspaper)
f4 <- sales ~ I(youtube + facebook + newspaper)
f4

modele4 <- lm( formula = f4, data = marketing, method="qr")

# analyse plus fine des coefficients avec estimation et test de significativité

resume4 <- summary(modele4)
resume4

# coeff détermination
resume4$r.squared

# analyse coeff
resume4$coefficients

# Prediction
# Une société investit 1500$ dans youtube et 1000$ dans facebook et 0$ en newspaper, estimer
ses ventes
vBeta2 <-modele4$coefficients
vBeta2

vVar2 <- c('(Intercept)'=1, 'I(youtube + facebook + newspaper)'=1500+1000+0)

vVar2

estSales2 <- vVar2 %*% vBeta2

estSales2

# Graphique d'une régression linéaire simple

library(ggplot2)
ggplot()+
geom_point(mapping=aes(x=marketing$youtube+marketing$facebook+marketing$newspaper,
y=marketing$sales))+
geom_smooth(mapping=aes(x=marketing$youtube+marketing$facebook+marketing$newspaper,
y=marketing$sales), method="lm",col="red")

# Calcul des coefficents par matrice

# Y~Xb b?
# (tXX)-1 tX.Y
X1 <- matrix(c(youtube=marketing$youtube , facebook=marketing$facebook,
newspaper=marketing$newspaper), ncol = 3)
X1

nrow(X)

vIntercept <- rep(1, nrow(X1))

X <- cbind(vIntercept, X1)
X

Y <- as.matrix(marketing$sales)

# (tXX)-1 tX.Y

b<- solve(t(X)%*%X)%*%t(X)%*%Y
b

# Credit Scoring

# scoringtools
# https://cran.r-project.org/web/packages/scoringTools/index.html
# Demo : https://cran.r-project.org/web/packages/scoringTools/vignettes/scoringTools.html

# Package et Dataframe

library(scoringTools)

# Environment > Global Environment ---> Package scoringTools

str(lendingClub)
# Combien de lignes ?
nrow(lendingClub)

# Exportation de Dataframe au format CSV (décimale française)

write.csv2(x=lendingClub, file='lending.csv')

# Filtrage des clients du dataframe

# 20 premières lignes et Afficher Amount_Requested, Loan_Length, Monthly_Income, Default

lendingClub[1:20,c("Amount_Requested", "Loan_Length", "Monthly_Income","Default")]

# n° 11 n'a pas honoré son prêt

# Ceux qui ont eux un défaut de paiement

# combien sont-ils ?
lendingClub[lendingClub$Default==1,c("Amount_Requested", "Loan_Length",
"Monthly_Income","Default")]
nrow(lendingClub[lendingClub$Default==1,c("Amount_Requested", "Loan_Length",
"Monthly_Income","Default")])
# Ceux de FICO 695-699
nrow(lendingClub[lendingClub$FICO_Range=="670-674",])
lendingClub2 <- lendingClub[lendingClub$FICO_Range=="670-674",]
lendingClub2

# Filtrage de colonne numériques

# conserver les variables numeriques
fnum1 <- function(v) is.numeric(v)

fnum1(v=23)
fnum1(v="MBF")

fnum1(v=lendingClub2)

# vectorisée
fnum <- Vectorize(fnum1, "v")

vNum <- fnum(v=lendingClub2)

vNum

# selection des variables numériques

lendingNum <- lendingClub2[vNum]

str(lendingNum)

# Regression généralisée

# Sigmoide
sig <- function (x) exp(x)/(1+exp(x))

plot(sig, from=-10, to=10)

# Logit
lgt <- function (x) log(x/(1-x))

plot(lgt, from=0, to=1)

sig(lgt(0.8))

# principe de la régression logistique

# regression logistique de la formule

# ecriture automatique de la formule

vNom1 <- names(lendingNum)
vNom1

vNom <- vNom1[vNom1!="Default"]

vNom

fAuto1 <- paste0("+",vNom[-1], collapse="")

fAuto1

fAuto2 <- paste0(vNom[1], fAuto1, collapse="")

fAuto2
fAuto3 <- paste0("Default~",fAuto2)
fAuto3

fScore <- as.formula(fAuto3)

fScore

# regression lgénéralisée avec ilen logit

modelScore <- glm( fScore, data = lendingNum, family = binomial(link = "logit"))

resumeScore <- summary(modelScore)

resumeScore

# Filtrage des Variables contributives

varScore <- resumeScore$coefficients
varScore[,4]<0.30

varScore[varScore[,4]<0.30 , ]

# Régression restreinte aux variables contributives

fScore2 <- Default ~ Amount_Requested + Debt_To_Income_Ratio + Monthly_Income +
Employment_Length

modelScore2 <- glm( fScore2, data = lendingNum, family = binomial(link = "logit"))

summary(modelScore2)

# Prediction de remboursement
dfVar2 <- data.frame(Amount_Requested = c(1500) , Debt_To_Income_Ratio=c(15),
Monthly_Income=c(4000), Employment_Length=c(8))
dfVar2

predLin <- predict( modelScore2 , newdata = dfVar2)

predLin
predProba <- sig(predLin)
predProba

# Prédiction Manuelle
# Coefficients
vCoef <- modelScore2$coefficients
vCoef
vVar <- c(Intercept=1, Amount_Requested = 1500 , Debt_To_Income_Ratio=15, Monthly_Income=4000,
Employment_Length=8)
vVar
pLinManu <- vCoef %*% vVar
pLinManu
predProbaManu <- sig(pLinManu)
predProbaManu

# Fonction de Scoring
fPred <- function ( Amount_Requested , Debt_To_Income_Ratio, Monthly_Income,
Employment_Length)
{
pLin <- vCoef %*% c(1, Amount_Requested , Debt_To_Income_Ratio, Monthly_Income,
Employment_Length)
pProb <- as.numeric(sig(pLin))
return(pProb)
}
fPred(Amount_Requested = 1500 , Debt_To_Income_Ratio=15, Monthly_Income=4000,
Employment_Length=8)

# À partir de quel montant la banque refuse-t-elle le prêt à ce client ?

fPred2 <- Vectorize(fPred, c("Amount_Requested"))

plot(x=seq(1500,40000,1000),y=fPred2(Amount_Requested = seq(1500,40000,1000) ,
Debt_To_Income_Ratio=15, Monthly_Income=4000, Employment_Length=8), type="line")

# Calcul manuel des coeffcients logistiques

# fScore2 <- Default ~ Amount_Requested + Debt_To_Income_Ratio + Monthly_Income +
Employment_Length

# Vraisemblance du Premier client

lendingNum$Default[1]
lendingNum$Amount_Requested[1]
lendingNum$Debt_To_Income_Ratio[1]
lendingNum$Monthly_Income[1]
lendingNum$Employment_Length[1]

fPred(Amount_Requested = 6000 , Debt_To_Income_Ratio=20.05, Monthly_Income=4891.67,

Employment_Length=6.487671)
vsb <- 1- fPred(Amount_Requested = 6000 , Debt_To_Income_Ratio=20.05, Monthly_Income=4891.67,
Employment_Length=6.487671)
log(vsb)

# Vraisemblance du 11e client

d<-lendingNum$Default[11]
lendingNum$Amount_Requested[11]
lendingNum$Debt_To_Income_Ratio[11]
lendingNum$Monthly_Income[11]
lendingNum$Employment_Length[11]

f<- fPred(Amount_Requested = 30000 , Debt_To_Income_Ratio=16.7, Monthly_Income=12500,

Employment_Length=12.47397)
vsb <- 1- fPred(Amount_Requested = 30000 , Debt_To_Income_Ratio=16.7, Monthly_Income=12500,
Employment_Length=12.47397)
f

log(vsb)

log(d*f+(1-d)*(1-f))

# Vraisemblance pour un client quelconque

fLogV <-function (vBeta, Default, Amount_Requested , Debt_To_Income_Ratio , Monthly_Income ,
Employment_Length)
{
pLin <- vBeta %*% c(1, Amount_Requested , Debt_To_Income_Ratio, Monthly_Income,
Employment_Length)
pProb <- as.numeric(sig(pLin))
return(log(pProb*Default+(1-pProb)*(1-Default)))
}
# Vérification
# client n°1
fLogV(vBeta = vCoef, Default=0, Amount_Requested=6000 , Debt_To_Income_Ratio=20.05,
Monthly_Income=4891.67, Employment_Length=6.487671)

# client n°11
fLogV(vBeta = vCoef, Default=1, Amount_Requested=30000 , Debt_To_Income_Ratio=16.67,
Monthly_Income=12500, Employment_Length=12.47397)

# Vraisemblance pour tous les clients

fLogVVect <- Vectorize(fLogV , c("Default", "Amount_Requested" , "Debt_To_Income_Ratio" ,
"Monthly_Income" , "Employment_Length"))

vLogV <- fLogVVect(vBeta=vCoef, Default=lendingNum$Default, Amount_Requested =

lendingNum$Amount_Requested , Debt_To_Income_Ratio=lendingNum$Debt_To_Income_Ratio,
Monthly_Income=lendingNum$Monthly_Income, Employment_Length=lendingNum$Employment_Length)
vLogV
sum(vLogV)

# Optimmisation du vecteur beta pour maximiser la vraisemblance

# Somme Log

sommeLogV<- function(vB)
{
return (sum(fLogVV(vBeta=vB, Default =lendingNum$Default, Amount_Requested =
lendingNum$Amount_Requested , Debt_To_Income_Ratio=lendingNum$Debt_To_Income_Ratio,
Monthly_Income=lendingNum$Monthly_Income, Employment_Length=lendingNum$Employment_Length)))
}

sommeLogV(vB = vCoef)

# Optimisation
resultat <- optim(par=c(0,0,0,0,0),fn=sommeLogV,control=list(fnscale=-1))
str(resultat)
resultat$par

# Comparer à vCoef
vCoef

TP3
# Fonction vectorielle et non vectorielle

g<- function(x) x**3

g(1:5)

# Faire function et if
# Vectorize
f <- function (x) sort(c(x, -x, 0))

f(1)

f(1:2) # pas une liste de vecteur !! mais un seul vecteur

#f <- function(x =1:3 , y) c(x, y)
vf <- Vectorize(f, "x", SIMPLIFY = F)
vf(1:2) # bien une liste
str(vf(1:2))
vf <- Vectorize(f, "x")
vf(1:2) # bien une matrice

# avec sapply
sapply(1:2, f) # une matrice

# quantmod

#install.packages("quantmod")
library(quantmod)
tsAAPL <- getSymbols(Symbols="AAPL", env=NULL, from = '2021-01-01' , to = Sys.Date() ,
periodicity = "daily")

str(tsAAPL)
names(tsAAPL)

# date

dt <- index(tsAAPL)
dt

# https://www.r-bloggers.com/2018/06/customizing-time-and-date-scales-in-ggplot2/
ggplot()+
geom_line(mapping=aes(x=dt, y=vaC))+
scale_x_date(date_labels = "%d %b %Y")

plot(tsAAPL$AAPL.Close)

# tracé avec quantmod

# https://www.quantmod.com/examples/charting/
# plot OHLC series Open High Lower Close
#chartSeries(tsAAPL, theme = chartTheme("white"))
candleChart(tsAAPL, theme = chartTheme("black"))
barChart(tsAAPL, theme = chartTheme("black"))

# Moving Average Convergence Divergence

# MACD is calculated by subtracting the long-term EMA (26 periods) from the short-term EMA (12
periods)
#
addMACD()

# Bande de Bollinger : https://admiralmarkets.com/fr/formation/articles/indicateurs-

forex/bandes-de-bollinger
# periode 20 Moyenne mobile
# et +2*ecart-type
# et -2*ecart-type
addBBands()
# *********************
# SMA EMA BBands
# *********************
# # SMA EMA
# https://en.wikipedia.org/wiki/Moving_average

# Calculer SMA 20 period

vaC <- as.vector(tsAAPL$AAPL.Close)
vaO <- as.vector(tsAAPL$AAPL.Open)
vaH <- as.vector(tsAAPL$AAPL.High)
vaL <- as.vector(tsAAPL$AAPL.Low)

# rendement Aplle à l'année

rdta <- (vaC[length(vaC)]-vaC[1])/vaC[1]
rdta

ggplot()+
geom_line(mapping=aes(x=dt, y=vaC))

# Calculer SMA
sma1<-function(v,t, period)
{
if (t<period) return(NA)
else return(mean(v[(t-period+1):t]))
}

sma1<-function(X,t, n) mean(X[max(1,(t-n+1)):t])

sma1(X=vaC, t=100,n=20)
sma1(X=vaC, t=10,n=20)
sma1(X=vaC, t=1,n=20)
# Calculer SMD (deviation)

smd1<-function(X,t, n) sd(X[max(1,(t-n+1)):t])
smd1(X=vaC, t=100,n=20)
smd1(X=vaC, t=10,n=20)
smd1(X=vaC, t=2,n=20)

# erreur sur sma1(vaC, 1:length(vaC), 3)

sma<- Vectorize(sma1, "t")

sma(X=vaC, t=1:5, n=20)

vsma <-sma(X=vaC, t=1:length(vaC), n=20)

smd <- Vectorize(smd1, "t")

smd(X=vaC, t=1:5, n=20)

vsmd <-smd(X=vaC, t=1:length(vaC), n=20)

vsmd
# ou bien sapply
vsma <- sapply(1:length(vaC), function(t) sma1(v=vaC, t, period=20 ))
vsma

ggplot()+
geom_candlestick(aes(x=dt, open = vaO, high = vaH, low = vaL, close = vaC))+
geom_line(aes(x=dt, y=vsma, color="X"))+
scale_x_date(date_labels = "%d %b %Y")+
scale_color_manual(values=c("X"="red"))

vaA1 <- vsma + 2*vsmd

vaA2 <- vsma - 2*vsmd
vaB1 <- vsma + vsmd
vaB2 <- vsma - vsmd

# tracé

# tidyquant : https://business-science.github.io/tidyquant/reference/geom_chart.html
#install.packages("tidyquant")
library(tidyquant)

ggplot()+
geom_candlestick(aes(x=dt, open = vaO, high = vaH, low = vaL, close = vaC))+
scale_x_date(date_labels = "%d %b %Y")

# Color : http://www.stat.columbia.edu/~tzheng/files/Rcolor.pdf

ggplot()+
geom_candlestick(aes(x=dt, open = vaO, high = vaH, low = vaL, close = vaC))+
geom_line(mapping=aes(x=dt, y=vsma, colour="X"))+
geom_line(mapping=aes(x=dt, y=vaA1, colour="A1"))+
geom_line(mapping=aes(x=dt, y=vaA2, colour="A2"))+
geom_line(mapping=aes(x=dt, y=vaB1, colour="B1"))+
geom_line(mapping=aes(x=dt, y=vaB2, colour="B2"))+
scale_x_date(date_labels = "%d %b %Y")+
scale_color_manual(values=c("A1"="cyan", "B1"="orange", "X"="red","B2"="orange",
"A2"="cyan"))

ggplot()+
geom_candlestick(aes(x=dt, open = vaO, high = vaH, low = vaL, close = vaC))+
geom_line(mapping=aes(x=dt, y=vsma, colour="X"))+
geom_line(mapping=aes(x=dt, y=vaA1, colour="A1"))+
geom_line(mapping=aes(x=dt, y=vaA2, colour="A2"))+
geom_line(mapping=aes(x=dt, y=vaB1, colour="B1"))+
geom_line(mapping=aes(x=dt, y=vaB2, colour="B2"))+
geom_ribbon(mapping = aes(x=dt, ymin=vaA2,ymax=vaB2), fill="gold", alpha=0.5)+
geom_ribbon(mapping = aes(x=dt, ymin=vaB2,ymax=vaB1), fill="darkgrey", alpha=0.5)+
geom_ribbon(mapping = aes(x=dt, ymin=vaB1,ymax=vaA1), fill="forestgreen", alpha=0.5)+
scale_x_date(date_labels = "%d %b %Y")+
scale_color_manual(values=c("A1"="cyan", "B1"="orange", "X"="red","B2"="orange",
"A2"="cyan"))
# Stratégie de "Double Bande Bollinger Day Trading"

K<-c()
S<-c()

K[1] <- 100000

S[1] <- 1000

tx <- 85/100

for (t in 2:length(vaC))
{
if (vaC[t]>vaB1[t] & vaC[t]<vaA1[t]) #achats
{
S[t] <- S[t-1] + K[t-1]*tx/vaC[t]
K[t] <- K[t-1]*(1-tx)
}
else if (vaC[t]>vaA2[t] & vaC[t]<vaB2[t]) #ventes
{
S[t] <- S[t-1]*(1-tx)
K[t] <- K[t-1] + S[t-1]*tx*vaC[t]
}
else
{
S[t] <- S[t-1]
K[t] <- K[t-1]
}
}

T<- K + S*vaC

rdtB <- (T[length(T)]-T[1])/T[1]

rdtB

library(gridExtra)
plot1 <- ggplot()+
geom_line(mapping=aes(x=dt, y=S, colour="S"))

plot2 <- ggplot()+

geom_line(mapping=aes(x=dt, y=K, colour="K"))

plot3 <- ggplot()+

geom_line(mapping=aes(x=dt, y=T, colour="T"))

grid.arrange(plot1, plot2, plot3, nrow=3, ncol=1)

rdtF <- function(tx)

{
K<-c()
S<-c()

K[1] <- 100000

S[1] <- 1000

for (t in 2:length(vaC))
{
if (vaC[t]>vaB1[t] & vaC[t]<vaA1[t]) #achats
{
 S[t] <- S[t-1] + K[t-1]*tx/vaC[t]
K[t] <- K[t-1]*(1-tx)
}
else if (vaC[t]>vaA2[t] & vaC[t]<vaB2[t]) #ventes
{
S[t] <- S[t-1]*(1-tx)
K[t] <- K[t-1] + S[t-1]*tx*vaC[t]
}
else
{
S[t] <- S[t-1]
K[t] <- K[t-1]
}
}

T<- K + S*vaC

return ((T[length(vaC)]-T[1])/T[1])
}

rdtF(tx=0.05)
rdtF(tx=0.95)

rdtFv <- Vectorize(rdtF, "tx")

txv <- seq(from=0, to=1,by=0.01)

rdtv<- rdtFv(tx=txv)

# mieux que stratégie passive ?

which(rdtv>rdta)
txSeuil <- txv[min(which(rdtv>rdta))]
txSeuil

#rdtL <- rdtFv(tx=txv)

#rdtv <- unlist(rdtL)
rdtv

ggplot()+
geom_line(mapping= aes(x=txv,y=rdtv))+
geom_hline(yintercept=rdta, color="red")

# Calculer EMA
#
t <- 100
period <- 20
alpha <- 2/(period+1)
weight <- (1-alpha)**(0:(period-1))
ema <- alpha*sum(vaC[t:(t-period+1)]*weight)
ema

ema1<-function(v,t, period)
{
if (t<period) return(NA)
else
 {
alpha <- 2/(period+1)
weight <- (1-alpha)**(0:(period-1))
# return( alpha*sum(vaC[(t-period+1):t]*weight) )
return( sum(v[t:(t-period+1)]*weight)/sum(weight) ) # version tronquée moyenne pondérée
}
}

ema1<-function(X,t, n)
{
n<- min(n,t)
alpha <- 2/(n+1)
weight <- (1-alpha)**(0:(n-1))
return( sum(X[t:(t-period+1)]*weight)/sum(weight) ) # version tronquée moyenne pondérée
}

ema1(X=vaC, t=100, n=12)

ema1(X=vaC, t=100, n=26)
ema1(X=vaC, t=5, n=12)
ema1(X=vaC, t=15, n=26)

#ema<- Vectorize(ema1, "t", SIMPLIFY = T)

ema<- Vectorize(ema1, "t")
vema12 <-ema(vaC, 1:length(vaC), 12)
vema26 <-ema(vaC, 1:length(vaC), 26)
vema12
vema26

# ou bien sapply
vema <- sapply(1:length(vaC), function(t) ema1(v=vaC, t, period=20 ))
vema

# tracé
ggplot()+
geom_candlestick(aes(x=dt, open = vaO, high = vaH, low = vaL, close = vaC))+
geom_line(mapping=aes(x=dt, y=vsma, colour="SMA 20"))+
geom_line(mapping=aes(x=dt, y=vema12, colour="EMA 12"))+
geom_line(mapping=aes(x=dt, y=vema26, colour="EMA 26")) +
scale_x_date(date_labels = "%d %b %Y")+
scale_color_manual(values=c("SMA 20"="red", "EMA 12"="orange", "EMA 26"="forestgreen"))

# MACD
# EMA 12period - EMA 26period
macd <- function(v,t) ema(v,t, n=12)-ema(v,t, n=26)
vmacd <- macd(vaC, 1:length(vaC))
# tracé
ggplot()+
geom_line(mapping=aes(x=1:length(vaC), y=vaC, colour="APPL"))+
geom_line(mapping=aes(x=1:length(vaC), y=vsma, colour="APPL SMA"))+
geom_line(mapping=aes(x=1:length(vaC), y=vema, colour="APPL EMA"))
geom_line(mapping=aes(x=1:length(vaC), y=vmacd, colour="APPL MACD"))

# tracé séparé
#install.packages("gridExtra")
#library(gridExtra)
plot1 <- ggplot()+
geom_candlestick(aes(x=dt, open = vaO, high = vaH, low = vaL, close = vaC))+
geom_line(mapping=aes(x=dt, y=vsma, colour="SMA 20"))+
geom_line(mapping=aes(x=dt, y=vema12, colour="EMA 12"))+
geom_line(mapping=aes(x=dt, y=vema26, colour="EMA 26")) +
scale_x_date(date_labels = "%d %b %Y")+
scale_color_manual(values=c("SMA 20"="red", "EMA 12"="orange", "EMA 26"="forestgreen"))

plot2 <- ggplot()+

geom_line(mapping=aes(x=dt, y=vmacd, colour="MACD"))+
scale_x_date(date_labels = "%d %b %Y")

grid.arrange(plot1, plot2, nrow=2, ncol=1, heights=c(2, 1))

# compare avec plot xts

chartSeries(tsAAPL$AAPL.Close)
addMACD()

TP4
GrapheBollinger.R
### MODELE ###

source("modele.R")
#gbollinger(ticker = "TTE", debut= as.Date("2022-05-01") , fin = as.Date("2022-11-01"), macd=F,
bbands=T)

### UI ###
library(shiny)

# Define UI for app that draws a histogram ----

ui <- fluidPage(

# App title ----

titlePanel("Bandes de Bollinger"),

# Sidebar layout with input and output definitions ----

sidebarLayout(

# Sidebar panel for inputs ----

sidebarPanel(

# DropDown list
selectInput(inputId = "ticker",
label = "Ticker :",
choices = c("AAPL", "GOOG", "MC", "TTE"),
),

# Input: Slider for the number of bins ----

sliderInput(inputId = "période",
label = "Date de début",
 min = as.Date("2022-01-01"),
max = Sys.Date(),
value = c(as.Date("2022-01-01"), Sys.Date())
),

checkboxInput(inputId="macd", label="MACD" , value = T),

),

# Main panel for displaying outputs ----

mainPanel(
plotOutput(outputId = "graphe")

)
)
)

### SERVER ###

# Define server logic required to draw a histogram ----

server <- function(input, output) {
output$graphe <- renderPlot({
tk1 <- input$ticker
str(tk1)
dt1 <- input$période

macd1 <- input$macd

gbollinger(ticker= tk1 ,debut=dt1 , fin=Sys.Date() , macd=macd1, bbands=T)

})
}

### Démarrage de Shiny ###

shinyApp(ui = ui, server = server)

Modele.R
# fonction de graphique
library("quantmod")

gbollinger <- function (ticker, debut, fin, macd, bbands) {

ts <- getSymbols(Symbols = ticker ,env=NULL,from=debut,to=fin, periodicity = "daily")

barChart(ts, theme="white")

if (bbands == T){
plot(addBBands())
}
if (macd == T){
plot(addMACD())
}
}