Travaux Pratiques #2
Algo & Prog avec R

Vous allez travailler sur des ordinateurs sous le système d’exploitation Windows (2ème étage) ou Linux (3ème étage). Peut-être utilisez-vous un ordinateur MacOS-X (basé sur UNIX comme Linux) ? Aucune importance puisque les logiciels qui nous serviront à programmer en R fonctionnent sur tous ces systèmes quasiment à l’identique. Nous supposons que vous savez utiliser votre ordinateur pour copier/déplacer des fichiers et lancer un logiciel ou un navigateur Web (Firefox, Chrome, etc).

Vous êtes donc devant votre machine. Vos notes de cours sont à portée de main et vos neurones commencent leurs échanges électro-chimiques, bravo !

En principe la machine est allumée, et en veille. En pressant une touche, elle devrait se réveiller et l’écran s’allumer. Appelez votre enseignant si ce n’est pas le cas, ou regardez comment font vos voisins … Vous arrivez sur une petite « fenêtre de dialogue » qui vous demande un nom d’utilisateur et un mot de passe (le vôtre).

Le bureau de Windows sert à abriter (le temps d’une séance de TP seulement) les fichiers des étudiants. Le bureau de Linux est sauvegardé d’une session à l’autre.

Nous vous demandons d’acheter une « clé USB » ou d’apprendre à utiliser un espace de stockage dans les nuages.

• Votre clef USB est un disque amovible : travaillez directement sur votre clé USB qui sera votre disque dur et espace de travail durant tous les TP.
• Votre espace de stockage est accessible grâce à votre navigateur : télécharger votre code source depuis cet espace au début de chaque séance et n’oubliez pas de le télécharger dans cet espace à la fin.

Nous allons utiliser une fonction sample tirant au hasard des éléments dans une collection, on dit aussi aléatoires. Voici 3 manières équivalentes de tirer un dé à 6 face, afficher un entier aléatoire entre [1,6]. Tapez les instructions ci-dessous.

sample(6, size=1)
sample(1:6, size=1)
sample(c(1, 2, 3, 4, 5, 6), size=1)

Faites afficher un entier aléatoire de [100,200] avec un appel à sample.

sample(100:200, size = 1)

Dans le cours d’électricité du lycée, vous avez sans doute vu que :

• la résistance équivalente de deux résistors R_1 et R_2 en série vaut R = R_1 + R_2,
• tandis que si les résistors sont placés en parallèle, leur résistance globale vérifie 1/R=1/R_1+1/R_2.

Un électronicien travaille avec la portion de circuit suivante contenant trois résistors. Programmez la fonction Circuit1(r1,r2,r3) retournant la résistance équivalente de ce circuit.
A.N. Pour r1=5 Ω, r2=100 Ω et r3=25 Ω, le résultat est 25 Ω.

       +----------+               +----------+
+------+    R1    +-------+-------+    R2    +------+---+
       +----------+       |       +----------+      |
                          |                         |
                          |       +----------+      |
                          +-------+    R3    +------+
                                  +----------+

Maintenant, programmez la fonction Circuit2(R1,R2,R3) retournant la résistance équivalente de ce circuit.

         +----------+                    +----------+
-+-------+    R1    +------+---+-+-------+    R2    +------+---+
 |       +----------+      |     |       +----------+      |
 |                         |     |                         |
 |       +----------+      |     |       +----------+      |
 +-------+    R2    +------+     +-------+    R3    +------+
 |       +----------+      |             +----------+
 |                         |
 |       +----------+      |
 +-------+    R3    +------+
         +----------+

Indice : définir une fonction auxiliaire Serie(r1, r2) (respectivement Parallele(r1, r2)) qui calcule la résistance globale de deux résistors en série (respectivement en parallèle).

Serie <- function(r1,r2) {r1+r2}
Parallele <- function(r1,r2) {return(r1 * r2 / (r1 + r2))}
# Le circuit est vue comme une composition de sous-circuits
circuit1 <- function(r1,r2,r3) {
  return(Serie(r1,Parallele(r2,r3)))
}
## \u03a9 : Unicode !
cat('La resistance totale du circuit 1 est',circuit1(5,100,25),'\u03a9.\n')

circuit2 <- function(r1,r2,r3) {
  return(Serie(Parallele(r1,Parallele(r2,r3)), Parallele(r2,r3)))
}
cat('La resistance totale du circuit 2 est',circuit2(5,100,25),'\u03a9.\n')

La resistance totale du circuit 1 est 25 Ω.
La resistance totale du circuit 2 est 24 Ω.

Programmez une fonction hconv(n) prenant un entier n > 0 représentant un nombre de secondes. L’effet de cette fonction est l’affichage d’une ligne exprimant la conversion de n secondes en heures-minutes-secondes.

hconv <- function(n) {
  s <- n %% 60;
  h <- n %/% 60;
  m <- h %% 60;
  h <- h %/% 60;
  cat(sprintf("%d -> %02d:%02d:%02d\n",n,h,m,s))
}

hconv(4567)
hconv(3601)
hconv(123456789)

4567 -> 01:16:07
3601 -> 01:00:01
123456789 -> 34293:33:09

Supposons que l’impôt sur le revenu annuel soit calculé par tranches de la manière suivante.

• Un salarié ne paye rien pour les 8000 premiers euros qu’il gagne.
• Il paye 10% sur chaque euro gagné entre 8000 € et 25000 €,
• et enfin 20% sur chaque euro gagné au-dessus de 25000 €.

1. Définissez la fonction Tranche(s,b,h,p) retournant l’impôt dû pour un salaire annuel s dans la tranche [b,h] dont le pourcentage est p %.
2. Définissez la fonction Impot(s) retournant l’impôt total dû pour un salaire annuel s.
3. Modifiez la fonction Impot(s) pour arrondir le montant de l’impôt au centime inférieur.
4. Testez plus finement votre fonction grâce à l’exercice UCAnCODE.

Tranche <- function(s, b, h, p) {
  if(s < b) return(0)   # rien
  else if (s <= h) return( (s - b) * p / 100) # une portion de la tranche
  else return((h - b) * p / 100)     # toute la tranche
}
ArrondiCentime <- function(x) floor(100 * x) / 100
Impot <- function(s) ArrondiCentime(Tranche(s,8000,25000,10)+Tranche(s,25000,s, 20))

Tranche(1500,2000,3000,10)
Tranche(2500,2000,3000,10)
Tranche(5000,2000,3000,10)
Tranche(5000,3000,3000,10)
Impot(40000)
Tranche <- function(s,b,h,p) max( min(s, h) - b, 0) * p / 100

[1] 0
[1] 50
[1] 100
[1] 0
[1] 4700

Tranche(1500,2000,3000,10)
Tranche(2500,2000,3000,10)
Tranche(4000,2000,3000,10)
Tranche(5000,3000,3000,10)
Impot(40000)

[1] 0
[1] 50
[1] 100
[1] 0
[1] 4700

1. Calculez l’hypoténuse d’un triangle connaissant les deux côtés de l’angle droit (a et b).
2. Demander à l’utilisateur de saisir les valeurs a et b à l’aide de la fonction scan()

3. Afficher et formatter le résultat avec les fonctions cat.

   cat("Veuillez entrer les longueurs des deux côtés de l’angle droit :\n")
   a <- scan( n = 1)
   b <- scan( n = 1)
   hypo <- sqrt(a**2 + b**2)
   cat("Longueur de l'hypoténuse :", hypo, '\n')
   

1. Définissez en R la fonction \(f(x)=\frac{sin(x)}{\sqrt{x^4+1}}\).
2. Calculez une valeur approchée de la dérivée seconde \(f^{\prime\prime}(\sqrt{2})\). Réponse : approximativement 0.036…

## Prenons une fonction f particuliere :
f <- function(x) sin(x)/sqrt(x**4 + 1)

## Calcul de la derivee premiere de f quelconque en un point x avec une precision de h
Deriv <- function(f, x, h = 2**(-10)) (f(x + h) - f(x)) / h
## formule vue au lycee...

cat('f\'(sqrt(2)) =',Deriv(f,sqrt(2)), '\n')

## Probleme : pour exprimer que la derivee seconde est la derivee de la derivee, j'ai
## besoin d'obtenir la FONCTION DERIVEE f' et pas seulement sa valeur en un point f'(x).
## En R, on définit une sous-fonction a l'interieur de Deriv et en rendant en resultat cette sous-fonction.
## C'est ce que les specialistes nomment une "fermeture" :
## http://fr.wikipedia.org/wiki/Fermeture_(informatique)

Deriv <- function(f, h = 2**(-10)) return (function(x) (f(x + h) - f(x)) / h)
## Du coup, je peux exprimer mes maths sans etat d'ame :
df <- Deriv(f)
d2f <- Deriv(df)
cat('f"(sqrt(2)) =',d2f(sqrt(2)), '\n')    # et zou ! Intellectuel non ?...

## Par contre, je vais rapidement avoir des problèmes de calcul numérique
df <- Deriv(f, h = 2**(-12))
d2f <- Deriv(df, h = 2**(-12))
cat('f"(sqrt(2)) =',d2f(sqrt(2)), '\n')    # et zou ! Problèmatique non ?...

## Une solution est de dériver symboliquement
df <- D(quote(sin(x) / sqrt(x^4 + 1)), 'x')
d2f <- D(df, 'x')
cat('la dérivée seconde de la fonction est\n')
print(d2f)
x <- sqrt(2)
cat('f"(sqrt(2)) =',eval(d2f), '\n')    # et zou ! Intriguant non ?...

f'(sqrt(2)) = -0.4300162
f"(sqrt(2)) = 0.03795618
f"(sqrt(2)) = 0.03691183
la dérivée seconde de la fonction est
-(sin(x)/sqrt(x^4 + 1) + cos(x) * (0.5 * (4 * x^3 * (x^4 + 1)^-0.5))/sqrt(x^4 +
    1)^2 + ((cos(x) * (0.5 * (4 * x^3 * (x^4 + 1)^-0.5)) + sin(x) *
    (0.5 * (4 * (3 * x^2) * (x^4 + 1)^-0.5 + 4 * x^3 * (-0.5 *
        (4 * x^3 * (x^4 + 1)^-1.5)))))/sqrt(x^4 + 1)^2 - sin(x) *
    (0.5 * (4 * x^3 * (x^4 + 1)^-0.5)) * (2 * (0.5 * (4 * x^3 *
    (x^4 + 1)^-0.5) * sqrt(x^4 + 1)))/(sqrt(x^4 + 1)^2)^2))
f"(sqrt(2)) = 0.03656271

Si cet exercice vous passe par-dessus la tete, ce n’est pas si grave que cela. Vous y reviendrez plus tard ! simple question de maturité…