CentraleSupélec LRI
Département informatique Équipe MODHEL
3 rue Joliot-Curie Bât 650 Ada Lovelace, Université Paris Sud
F-91192 Gif-sur-Yvette cedex, France Rue Noetzlin, 91190 Gif-sur-Yvette, France
Enseignement

Table des matières

Exemples de code, techniques de programmation Exemples

Des exemples montrant comment résoudre des problèmes récurrents en Java : lire et écrire dans un fichier, créer une interface graphique, sélectionner un fichier, lire et écrire un fichier XML etc.

Une page sur l'utilisation de Greenfoot avec ou sans Eclipse

Exemples et documentation pour le cours de troisième année Concepts des langages et techniques de programmation

Première année 1ère année

Architecture des ordinateurs ARCHI

7 cours, 3 séances de travaux dirigés, 2 séances d'études de laboratoire

Voir le site du cours pour plus de détails.

Génie logiciel

Premier TD, nombre secret

package jeu;

import java.util.Scanner;

public class NombreSecret {
	//@ Return a random integer in the range [min, max]
	private static int genRandInt(int min, int max) {
		// Use Math.round so that max can be reached even if Math.random is in [0, 1[
		return (int) Math.round(min + Math.random()*(max - min));
	}

	//@ Tell when the number has been guessed, and print a message
	private static boolean comparer(int v, int sec) {
		if (v == sec) {
			System.out.println("Gagné !");
			return true;
		} else if (v < sec) {
			System.out.println("Trop petit");
		} else {
			System.out.println("Trop grand");
		}
		return false;
	}

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		boolean fini = false; // Is the user done with the game?

		while (! fini) {
			int secret = genRandInt(0, 100);  // Create a new secret number to guess
			boolean trouve = false;           // The user did notguess it yet 
			int tentatives = 0;               // Number of trials performed
			int essais[] = new int[10];       // Values guessed at each trial

			System.out.println("Trouvez le nombre secret !");

			while ((! trouve) && (tentatives < 10)) {
				System.out.print("Entrez une valeur : ");
				int val = s.nextInt();
				essais[tentatives] = val;
				tentatives++;
				trouve = comparer(val, secret);
			}
			if (! trouve) {
				System.out.println("Perdu !");
			}
			System.out.println("Vos tentatives :");
			for (int i = 0; i < tentatives; i++) {
				System.out.print(essais[i] + " ");
			}
			System.out.println();
			System.out.println("Le secret était " + secret);
			System.out.print("Voulez-vous rejouer (O/N) ?");
			String reponse = s.next();
			if (reponse.toUpperCase().charAt(0) != 'O') {
				// If the first character of the upper case version of the answer is not 'O'
				// the user wants to stop playing.
				fini = true;
			}
		}
		s.close();
	}
}

Premier BE (TDs 2 et 3)

//@ Rational numbers
public class Rational {
	private final int num; // "final" means we cannot change this value
	private final int den;

	//@ Build a Rational num/den
	public Rational(int num, int den) {
		this.num = num;
		this.den = den;
	}

	//@ Return the numerator of this rational
	public int getNumerator() {
		return num;
	}

	//@ Return the denominator of this rational
	public int getDenominator() {
		return den;
	}

	//@ Is this rational null?
	public boolean isZero() {
		return num == 0;
	}

	//@ Is this rational equal to 1?
	public boolean isOne() {
		return num == den;
	}

	//@ Return a string representation of this rational
	@Override
	public String toString() {
		if (den == 1) {
			return Integer.toString(num);
		}
		if (num == 0) {
			return "0";
		}
		return num + "/" + den;
	}

	//@ Return the sum of this rational and 'other'
	public Rational add(Rational other) {
		return new Rational(this.num * other.den + other.num * this.den,
				            this.den * other.den);
	}

	//@ Return the product of this rational and 'other'
	public Rational multiply(Rational other) {
		return new Rational(this.num * other.num, this.den * other.den);
	}

	//@ Return the greatest common divisor of 'a' and 'b'
	public static int gcd(int a, int b) {
		if (a == 0) {
			return b;
		}
		if (b == 0) {
			return a;
		}
		a = Math.abs(a);
		b = Math.abs(b);

		while (a != b) {
			if (a > b) {
				a = a - b;
			} else {
				b = b - a;
			}
		}
		return a;
	}

	//@ Return a simplified version of this rational
	public Rational simplify() {
		if (isZero()) {
			return new Rational(0,1);
		}
		int gcd = gcd(this.num, this.den);
		return new Rational(this.num/gcd, this.den/gcd);
	}

	//@ Return an approximate value of this rational
	public double approximate() {
		return ((double)this.num) / this.den;
	}
}
public class RationalTest {
	public static void main(String[] args) {
	    Rational q = new Rational(3, 4);
	    System.out.println("q = " + q);
	    Rational r = new Rational(1, 6);
	    System.out.println("r = " + r);
	    Rational s = q.add(r).simplify();
	    System.out.println("q+r = " + s);
	    Rational p = q.multiply(r).simplify();
	    System.out.println("q*r = " + p);

	    System.out.println("gcd(-12, 18) = " + Rational.gcd(12, 18));

	    System.out.println("q ≈ " + q.approximate());
	    System.out.println("r ≈ " + r.approximate());
	}
}
//@ Monomial with rational coefficient
public class Monomial {
	private Rational coef;
	private int exp;

	//@ Build a monomial 'coef' time x to the 'exp' power
	public Monomial(Rational coef, int exp) {
		this.coef = coef;
		this.exp = exp;
	}

	//@ Build a monomial with same coefficient and exponent as 'm'
	public Monomial(Monomial m) {
		this.coef = m.coef;
		this.exp = m.exp;
	}

	//@ Build the string representation of the x^n part of this monomial
	private String xString() {
		if (exp == 0) {
			// If the exponent is null, we display nothing (same as 1)
			return "";
		}
		if (exp == 1) {
			// If the exponentent is one, do not display it
			return "*X";
		}
		// Basic case
		return "*X^" + this.exp;
	}

	//@ Return a string representation of this monomial
	@Override
	public String toString() {
		if (coef.isOne()) {
			// If the coefficient is 1, do not display it...
			String xs = xString();
			if (xs.length() == 0) {
				// ... unless the exponent is null
				return "1";
			} else {
				return xs;
			}
		}
		// Basic case
		return this.coef + xString();
	}

	//@ Return the coefficient of this monomial
	public Rational getCoef() {
		return this.coef;
	}

	//@ Retuen the degree of this monomial
	public int getDegree() {
		return this.exp;
	}

	//@ Return the value of this monomial for a given value of x
	public Rational evaluate(Rational x) {
		Rational res = new Rational(1,1);
		for (int i = 0; i < this.exp; i++) {
			res = res.multiply(x);
		}
		res = res.multiply(coef);
		return res.simplify();
	}

	//@ Return the product of this monomial and 'm'
	public Monomial multiply(Monomial m) {
		return new Monomial(coef.multiply(m.coef).simplify(), exp + m.exp);
	}
}
public class MonomialTest {
	public static void main(String[] args) {
		Monomial m = new Monomial(new Rational(3,4), 5);
		System.out.println(m);
		System.out.println(m.evaluate(new Rational(2,5)));
		Monomial one = new Monomial(new Rational(1,1), 0);
		System.out.println(one);
	}
}
import java.util.TreeMap;

//@ Polynomials with rational coefficients
public class Polynomial {
	private TreeMap<Integer, Monomial> monomials;

	//@ Build a polynomial from an array of monomials
	public Polynomial(Monomial monomials[]) {
		this.monomials = new TreeMap<Integer, Monomial>();
		for (Monomial m : monomials) {
			// Using add ensures that everything is OK even 
			// if several monomials in the array have the same degree.
			this.add(m);
		}
	}

	//@ Build a polynomial as a copy of 'p'
	public Polynomial(Polynomial p) {
		this.monomials = new TreeMap<Integer, Monomial>();
		for (Monomial m : p.monomials.values()) {
			monomials.put(m.getDegree(), new Monomial(m));
		}
	}

	//@ Return a string representation of this polynomial
	@Override
	public String toString() {
		// Using a StringBuffer is much more efficient than concatenating strings
		StringBuffer buf = new StringBuffer();
		boolean first = true;
		for (Monomial m : this.monomials.values()) {
			if (first) {
				// First time: do not append the '+' sign
				first = false;
			} else {
				// Next times: separate from the previous monomial with a '+' sign
				buf.append(" + ");
			}
			buf.append(m);
		}
		// The result is just the string in the StringBuffer
		return buf.toString();
	}

	//@ Return the degree of this polynomial
	public int getDegree() {
		int d = 0;
		boolean first = true;
		// Go through all the monomials, looking for a max
		for (Monomial m : this.monomials.values()) {
			int md = m.getDegree();
			if (first || md > d) {
				// If first is true, initialize d
				// If md > d, update d with a greater degree
				d = md;
				first = false; // First time is only once...
			}
		}
		return d;
	}

	//@ Return the value of this polynomial for a given x
	public Rational evaluate(Rational x) {
		Rational res = new Rational(0, 1);
		for (Monomial m : this.monomials.values()) {
			res = res.add(m.evaluate(x));
		}
		return res.simplify();
	}

	//@ Add a monomial to this polynomial
	private void add(Monomial m) {
		int deg = m.getDegree();
		// Look for an existing monomial with the same degree
		Monomial mm = monomials.get(deg);
		if (mm == null) {
			// If there is none, add the monomial to the TreeMap
			monomials.put(deg, m);
		} else {
			// Else, compute the coefficient of the resulting monomial
			Rational c = mm.getCoef().add(m.getCoef()).simplify();

			if (c.isZero()) {
				// If the new monomial cancels an existing monomial,
				// remove it from the TreeMap
				monomials.remove(deg);
			} else {
				// Else update the tree map
				monomials.put(deg, new Monomial(c, deg));
			}
		}
	}

	//@ Return the sum of this polynomial and 'p'
	public Polynomial add(Polynomial p) {
		// First, build a copy of this polynomial
		Polynomial res = new Polynomial(this);
		// Add all the monomials of 'p' to it
		for (Monomial m : p.monomials.values()) {
			res.add(m);
		}
		return res;
	}

	//@ Return the product of this polynomial and 'p'
	public Polynomial multiply(Polynomial p) {
		// Build an empty polynomial
		Polynomial res = new Polynomial(new Monomial[]{});
		// Distribute the product over the addition
		for (Monomial m1 : this.monomials.values()) {
			for (Monomial m2 : p.monomials.values()) {
				res.add(m1.multiply(m2));
			}
		}
		return res;
	}
}
public class PolynomialTest {
	public static void main(String[] args) {
		Monomial monomials[] = new Monomial[3];
		monomials[0] = new Monomial(new Rational(3,4), 5);
		monomials[1] = new Monomial(new Rational(7,2), 2);
		monomials[2] = new Monomial(new Rational(4,3), 0);
		Polynomial p = new Polynomial(monomials);

		System.out.println("p = " + p);

		System.out.println("Degré de p = " + p.getDegree());

		Rational v = p.evaluate(new Rational(2,5));
		System.out.print(v);
		System.out.println(" ≈ " + v.approximate());

		Monomial mm[] = new Monomial[2];
		mm[0] = new Monomial(new Rational(1,2), 4);
		mm[1] = new Monomial(new Rational(-7,2), 2);
		Polynomial q = new Polynomial(mm);
		System.out.println("q = " + q);
		System.out.println("p+q = " + p.add(q));
		System.out.println("p*q = " + p.multiply(q));
	}
}

TD6 (OCL)

Deuxième année 2ème année

Projets de développement logiciel Projets

Projets pour la séquence 6 en 2016-2017 (identification nécessaire avec votre nom d'utilisateur et mot de passe Supélec)

Voir les consignes pour les élèves dont j'encadre le projet.

Troisième année 3ème année

Modélisation des systèmes Modélisation

7 cours, 1 bureau d'étude (+6 cours et 1 bureau d'étude par Lina Ye)

Examen

Objectif

Ce module présente les techniques de modélisation des systèmes qui permettent de concevoir un système informatique, de simuler son fonctionnement ainsi que l’environnement dans lequel il devra fonctionner, et de générer son code pour une plateforme. L’accent est mis sur la disponibilité de différents modèles adaptés aux différentes parties d’un système et sur la possibilité d’utiliser conjointement ces modèles.

Programme

  • Modélisation, abstraction
    Modèles et interprétation des modèles. Modèles exécutables, calculables, prédictifs, explicatifs. Modèles classiques: temps continu, temps discret périodique, flots de données synchrones, événements discrets, automates hiérarchiques, systèmes réactifs synchrones.
  • Modélisation et validation
    Ordonnancement, Allocation de ressources (CPU, mémoire). Vérifications formelles: propriétés mathématiques des modèles, preuves, model-checking, application à la sûreté de fonctionnement.
  • Ingénierie dirigée par les modèles
    Relations entre systèmes, modèles et métamodèles
    Définition d'un langage de modélisation (DSL), transformations de modèles
  • Hétérogénéité et interactions entre modèles
    Hiérarchies de modèles. Problèmes aux limites entre modèles: continu/discret, flots de données/événements. Systèmes modaux.
  • Application à la modélisation d’un système
    Approche réactive synchrone pour le contrôle + preuve formelle, approche à flots de données pour les traitements, temps continu pour la modélisation de l’environnement du système.

Transparents du cours

Les transparents :

Cours sur machine : métamodèles, modèles et transformations de modèle.

Une version ancienne du polycopié du cours est également disponible.

Bureau d'étude

Le sujet du bureau d'étude n° 1 (création d'un DSL)

Sémantique des langages Sémantique

5 cours, 1 bureau d'étude

Bureau d'étude preuve de programmes avec Krakatoa/Why

Objectif

Ce module présente différentes techniques permettant de définir la sémantique d'un langage de programmation.

Programme

  • Syntaxe concrète, syntaxe abstraite
  • Syntaxe abstraite et sémantique
  • Sémantique traductionnelle
  • Sémantique opérationnelle (petits et grands pas)
  • Sémantique dénotationnelle
  • Sémantique axiomatique
  • Sémantique des définitions récursives
  • Application au langage Niklaus

À partir de 2015, les définitions sémantiques sont faites en Isabelle/HOL.

Ressources :

  • Tutoriel : définition d'un type liste et preuve de théorèmes
  • Niklaus : le langage repris du cours de traitement des langages et ses différents styles de sémantique.