Cours 23.02

.gitignore

@@ -0,0 +1,6 @@
+.bloop/
+.bsp/
+.metals/
+target/
+
+

build.sbt

@@ -0,0 +1,14 @@
+val scala3Version = "3.1.0"
+
+lazy val root = project
+  .in(file("."))
+  .settings(
+    name := "hepiascala",
+    version := "2.1.0",
+    scalaVersion := scala3Version,
+    libraryDependencies ++= Seq(
+      //Dépendences
+    ),
+    Compile / scalaSource := baseDirectory.value / "src",
+    Test / scalaSource := baseDirectory.value / "test-src"
+  )

consignes/tp1.md

@@ -0,0 +1,36 @@
+# TP 1
+
+Les buts de ce TP sont:
+- de configurer un environement de travail; 
+- prendre en main l'outil SBT;
+- découvrir la syntaxe de base de Scala 3. 
+
+## Installation de SBT
+
+Installez l'outil SBT (obligatoire) pour compiler et exécuter le code. Celui-ci dépend de Java.
+
+Plusieurs options d'installation:
+
+- Votre distribution (Linux)
+- Le script [sbt-extras](https://github.com/dwijnand/sbt-extras) (Linux ou MacOS)
+- Le [site officiel](https://www.scala-sbt.org/) (Windos ou MacOS)
+- Cloner le site du cours, allez à la racine, et lancez `sbt`, les commandes
+  suivantes se lanceront dans le shell `sbt` directement.
+
+## Tester SBT
+
+- Pour compiler le projet: `compile`. La première fois il télécharge tout ce dont il a besoin.
+- Pour accéder à un interpréteur Scala: `console`.
+- Exécutez le _Hello, World_ avec: `runMain  ch.hepia.tp.hello`.
+
+## Premier TP
+
+- Etudiez le fichier `src/helloWorld.scala`
+- Etudier le fichier `src/tp1.scala`
+- Exécutez ce dernier fichier avec `runMain ch.hepia.tp.tp1`
+- Implémenter les fonctions, jusqu'à ce que tout soit bon
+
+### ATTENTION
+
+Les seuls mots-clés autorisés sont `val`, `def`, `if` et `else`. Tous les autres
+sont strictement interdits (pas de `var`, `while`, `return`, etc.)

project/build.properties

@@ -0,0 +1 @@
+sbt.version=1.8.2

src/helloWorld.scala

@@ -0,0 +1,4 @@
+package ch.hepia.tp
+
+@main
+def hello = println("Hello, world !")

src/tp1.scala

@@ -0,0 +1,65 @@
+package ch.hepia.tp
+
+//Calcule la valeur absolue d'un double
+def abs( x: Double ): Double =
+  if( x < 0 ) -x else x
+
+//A IMPLEMENTER
+//doit retourner 1 si x est positif, -1 si x est négatif
+//et 0 sinon
+def sign( x: Double ): Double = 0
+
+//A IMPLEMENTER
+//C'est juste la fonction factorielle
+def fac( n: Long ): Long = -1
+
+//A IMPLEMENTER
+//L'algorithme suivant est en pseudocode. Traduisez le
+//en Scala, en utilisant uniquement les mots-clé autorisés
+//
+//function gcd(a, b)
+//    while b ≠ 0
+//        t := b
+//        b := a mod b
+//        a := t
+//    return a
+def gcd( a: Int, b: Int ): Int = -1
+
+
+//Calcule l'aire d'un cercle au quel on aurait enlever le carré inscrit
+def weirdShapeArea( radius: Double ) = {
+  val r2 = radius*radius
+  val disc = math.Pi * r2
+  val square = 2*r2
+  disc - square
+}
+
+//A IMPLEMENTER:
+//La distance euclidienne entre deux points (x1,y1) et (x2,y2)
+def distance( x1: Double, y1: Double, x2: Double, y2: Double ) =
+  -1e-1
+
+
+//A FAIRE
+//Décommenter les lignes suivantes une à une
+//Essayer de comprendre l'erreur et de la résoudre
+//Le résultat final n'a pas d'importance
+def foobar(): Int = {
+  val x = 2
+  //x = x + 1
+  //if( x == "3" )
+  //  println( "Trois: " + x )
+  //else
+   x
+}
+
+@main
+def tp1 = {
+  println( "TP1 (tout doit être à 'true'):" )
+  println( s"  Fonction abs: ${abs(-3.1)*sign(-3.1) == -3.1}" )
+  println( s"  Fonction fac: ${fac(8) == 40320}" )
+  println( s"  Fonction gcd: ${gcd(1071, 462) == 21}" )
+  println( s"  Fonction distance (1): ${distance(1,2,1,2) == 0}" )
+  println( s"  Fonction distance (2): ${distance(1,2,3,4) == distance(3,4,1,2)}" )
+  println( s"  Fonction distance (3): ${distance(1,0,0,1) == math.sqrt(2)}" )
+}