Correction md2 fabien orienté object

Correction des exercices de programmation objet
Fabien Napolitano
19 d´cembre 2000
e

1 Exercices en mode texte
Exercice 1.1 :
public class Chronometre {
private long time ;

public Chronometre() {}

public void start() {
time=System.currentTimeMillis() ;
}

public long stop() {
return System.currentTimeMillis()-time ;
}
}
————————–

Exercice 1.2 :
public class Date implements Comparable {
// nombre de jours depuis le 1er Janvier 4713 avant JC
private int numeroJulien ;
// noms des mois de l’annee
private static String[] mois={"janvier","fevrier","mars","avril","mai","juin",
"juillet","aout","septembre","octobre","novembre","decembre"} ;
// noms des jours de la semaine
private static String[] jour={"dimanche","lundi","mardi","mercredi","jeudi",
"vendredi","samedi"} ;

// constructeur avec le numero Julien
public Date(int n) {
numeroJulien=n ;
}

// constructeur avec la date sous la forme classique
public Date(int jour,int mois,int annee) {
int a=(14-mois)/12 ;
int y=annee+4800-a ;
int m=mois+12*a-3 ;
//
numeroJulien=jour+(153*m+2)/5+y*365+y/4-y/100+y/400-32045 ;
}

public boolean equals(Object obj) {
if (!(obj instanceof Date)) return false ;
Date date=(Date)obj ;
return (numeroJulien==date.numeroJulien) ;
}

public int compareTo(Object obj) {
// provoque une erreur si obj n’est pas de type date
Date date=(Date)obj ;
return (numeroJulien-date.numeroJulien) ;
}

public void next() { // jour suivant
numeroJulien++ ;
}

public void previous() { // jour precedenf
numeroJulien-- ;
}

public int[] getUsualForm() {
int a = numeroJulien + 32044 ;
int b = (4*a+3)/146097 ;
int c = a - (b*146097)/4 ;
int d = (4*c+3)/1461 ;
int e = c - (1461*d)/4 ;
int m = (5*e+2)/153 ;
int[] jma=new int[3] ;
jma[0]=e-(153*m+2)/5+1 ;
jma[1]=m+3-12*(m/10) ;
jma[2]=b*100+d-4800+m/10 ;
return jma ;
}

public int getJour() {
return getUsualForm()[0] ;
}

public int getMois() {
}

public int getAnnee() {
}

public String nomDuJour() {
// 0 pour dimanche, 1 pour lundi, ....
int n=(numeroJulien-1720977)%7 ;
return jour[n] ;
}

public String nomDuMois() {
return mois[getMois()-1] ;
}

F. Napolitano – 19 d´cembre 2000 (Version 1.0)
e p. 2

public String toString() {
return nomDuJour()+" "+getJour()+" "+
nomDuMois()+" "+getAnnee() ;
}
}
————————–

Exercice 1.3 :
import java.util.Random ;
public class De {
private static Random aleatoire ;
private int value ;

public De() {
// creation d’une instance de Random si ca n’est pas
// deja fait
if (aleatoire==null) {
aleatoire=new Random(System.currentTimeMillis()) ;
}
roll() ;
}

public void roll() {
value=aleatoire.nextInt(6)+1 ;
}

public int getValue() {
return value ;
}
}
————————–

Exercice 1.4 :
public class Random {
private final static int A=48271 ;
private final static int M=2147483647 ; // =2^31-1
private final static int Q=M/A ;
private final static int R=M%A ;

private int etat ; // dernier nombre aleatoire

public Random(int seed) {
etat=seed ;
}

public int nextInt() {
etat=A*(etat%Q)-R*(etat/Q) ;
if (etat<0)
etat+=M ;
return etat ;
}

public int nextInt(int n) {

e p. 3

return (nextInt()%n) ;
}
}
————————–

Exercice 1.5 :

————————–

Exercice 1.6 :
public class Caractere {
private static int hauteur=8 ;
private static int largeur=8 ;
private int[] representation ;

public Caractere() {
representation=new int[largeur*hauteur] ;
}

public Caractere(String s) {
representation=new int[largeur*hauteur] ;
for (int i=0;i<representation.length;i++)
if (s.charAt(i)==’ ’)
representation[i]=-1 ;
else
representation[i]=1 ;
}

public int[] getVector() {
return representation ;
}

if (!(obj instanceof Caractere)) return false ;
Caractere c=(Caractere)obj ;
for (int i=0;i<representation.length;i++)
if (representation[i]!=c.representation[i]) return false ;
return true ;
}

StringBuffer sb=new StringBuffer() ;
for (int i=0;i<representation.length;i++) {
// passage a la ligne
if ((i%largeur)==0)
sb.append(’n’) ;
if (representation[i]==-1)
sb.append(’ ’) ;
else
sb.append(’*’) ;
}
return sb.toString() ;
}
}

e p. 4

————————–
public class Hopfield {
private int memory=0 ;
// on suppose que les Caractere sont de taille 8*8
private int[][] coefficients=new int[64][64] ;
// variable aleatoire utile dans la methode evalue
private static Random alea=new Random((int)System.currentTimeMillis()) ;

// le constructeur est implicite

public boolean learn(Caractere c) {
memory++ ;
if (memory>0.15*64) return false ;
int[] tab=c.getVector() ;
for (int i=1;i<64;i++)
for (int j=1;j<64;j++)
if (i!=j)
coefficients[i][j]+=tab[i]*tab[j] ;
return true ;
}

public Caractere evolue(Caractere c) {
int[] tab=c.getVector() ;
int i=alea.nextInt(64) ;
int somme=0 ;
for (int j=1;j<64;j++)
somme+=coefficients[i][j]*tab[j] ;
if (somme>0)
tab[i]=1 ;
if (somme<0)
tab[i]=-1 ;
// agit par effet de bord sur c
return c ;
}

public static void main(String[] arg) {
// Caracteres que l’on apprend au reseau
Caractere a=new Caractere(
" ** "+
" **** "+
" ** ** "+
" ** ** "+
" ****** "+
"********"+
"*** ***"+
"*** ***") ;
Caractere x=new Caractere(
"* *"+
"** **"+
" ** ** "+
" **** "+
" **** "+
" ** ** "+
"** **"+
"* *") ;

e p. 5

Caractere y=new Caractere(
"* *"+
"** **"+
" ** ** "+
" **** "+
" ** "+
" ** "+
" ** "+
" ** ") ;
Caractere z=new Caractere(
"********"+
"********"+
" **"+
" ** "+
" ** "+
"** "+
"********"+
"********") ;
Hopfield reseau=new Hopfield() ;
reseau.learn(a) ;
reseau.learn(x) ;
reseau.learn(y) ;
reseau.learn(z) ;
// caractere a reconnaitre
Caractere aBruite=new Caractere(
" ** "+
" **** "+
" ** ** "+
" * ** "+
" *** ** "+
"********"+
"*** ***"+
"*** *") ;
while (!aBruite.equals(a)) {
System.out.println() ;
aBruite=reseau.evolue(aBruite) ;
System.out.println(aBruite) ;
}
System.out.println(a) ;
}
}
————————–

2 Exercices dur les structures de donn´es
e

Exercice 2.1 :
public class CaseListeChainee {
private Object contenu ;
private CaseListeChainee caseSuivante ;
private CaseListeChainee casePrecedente ;

public CaseListeChainee(Object obj) {
contenu=obj ;

e p. 6

}

public CaseListeChainee(Object obj,CaseListeChainee s) {
contenu=obj ;
if (s!=null)
setCaseSuivante(s) ;
}

public Object getContenu() {
return contenu ;
}

public void setContenu(Object obj) {
contenu=obj ;
}

public CaseListeChainee getCaseSuivante() {
return caseSuivante ;
}

public CaseListeChainee getCasePrecedente() {
return casePrecedente ;
}

public void setCaseSuivante(CaseListeChainee suivante) {
if (caseSuivante!=null)
caseSuivante.casePrecedente=null ;
caseSuivante=suivante ;
if (caseSuivante==null) return ;
if (caseSuivante.casePrecedente!=null)
caseSuivante.casePrecedente.caseSuivante=null ;
caseSuivante.casePrecedente=this ;
}

public void setCasePrecedente(CaseListeChainee precedente) {
if (casePrecedente!=null)
casePrecedente.caseSuivante=null ;
casePrecedente=precedente ;
if (casePrecedente==null) return ;
if (casePrecedente.caseSuivante!=null)
casePrecedente.caseSuivante.casePrecedente=null ;
casePrecedente.caseSuivante=this ;
}

if (!(obj instanceof CaseListeChainee)) return false ;
CaseListeChainee c=(CaseListeChainee)obj ;
return (c.getContenu().equals(getContenu())) ;
}
}
————————–
public class ListeChainee {
private CaseListeChainee premiere ;
private CaseListeChainee derniere ;

e p. 7

private int size=0 ;

public ListeChainee() {}

public int size() {
return size ;
}

public boolean isEmpty() {
return size==0 ;
}

public void addFirst(Object obj) {
// l’ancienne premiere devient la deuxieme
premiere=new CaseListeChainee(obj,premiere) ;
// si la liste etait vide la premiere coincide
// maintenant avec la derniere
if (size==0)
derniere=premiere ;
size++ ;
}

public void addLast(Object obj) {
if (size!=0) {
derniere.setCaseSuivante(new CaseListeChainee(obj)) ;
derniere=derniere.getCaseSuivante() ;
}
else {
derniere=new CaseListeChainee(obj) ;
premiere=derniere ;
}
size++ ;
}

public Object getFirst() {
if (!isEmpty())
return premiere.getContenu() ;
return null ;
}

public Object getLast() {
if (!isEmpty())
return derniere.getContenu() ;
return null ;
}

public Object removeFirst() {
Object obj=null ;
if (!isEmpty()) {
obj=premiere.getContenu() ;
size-- ;
if (isEmpty()) {
derniere=null ;
premiere=null ;
}

e p. 8

else {
premiere=premiere.getCaseSuivante() ;
premiere.setCasePrecedente(null) ;
}
}
return obj ;
}

public Object removeLast() {
Object obj=null ;
if (!isEmpty()) {
obj=derniere.getContenu() ;
size-- ;
if (isEmpty()) {
derniere=null ;
premiere=null ;
}
else {
derniere=derniere.getCasePrecedente() ;
derniere.setCaseSuivante(null) ;
}
}
return obj ;
}

public Object get(int index) {
if (index>=size) return null ;
CaseListeChainee temp=premiere ;
for (int i=0;i<index;i++)
temp=temp.getCaseSuivante() ;
return temp.getContenu() ;
}

public Object set(int index,Object obj) {
if (index>=size) return null ;
for (int i=0;i<index;i++)
Object old=temp.getContenu() ;
temp.setContenu(obj) ;
return old ;
}

// ajoute l’objet obj a la position index
public void add(int index,Object obj) {
if (index<=0) {
addFirst(obj) ;
return ;
}
if (index>size) {
addLast(obj) ;
return ;
}
CaseListeChainee nouvelle=new CaseListeChainee(obj) ;
CaseListeChainee temp1=premiere ;

e p. 9

CaseListeChainee temp2=temp1.getCaseSuivante() ;
for (int i=0;i<index-1;i++) {
temp1=temp2 ;
temp2=temp2.getCaseSuivante() ;
}
temp1.setCaseSuivante(nouvelle) ;
nouvelle.setCaseSuivante(temp2) ;
size++ ;
}

StringBuffer sb=new StringBuffer("|") ;
while (temp!=null) {
sb.append(temp.getContenu()) ;
sb.append(’|’) ;
}
}

if (!(obj instanceof ListeChainee)) return false ;
ListeChainee list=(ListeChainee)obj ;
if (size()!=list.size()) return false ;
CaseListeChainee temp1=premiere ;
CaseListeChainee temp2=list.premiere ;
while (temp1!=null) {
if (!temp1.equals(temp2))
return false ;
}
return true ;
}

public boolean contains(Object obj) {
while (temp!=null) {
if (obj.equals(temp.getContenu())) return true ;
}
return false ;
}

public Object[] toArray() {
Object[] tab=new Object[size()] ;
for (int i=0;i<size();i++) {
tab[i]=temp.getContenu() ;
}
return tab ;
}
}

e p. 10

————————–

Exercice 2.2 :
Cf. section 5.

Exercice 2.3 :
public class Pile {
private ListeChainee contenu ;

public Pile() {
contenu=new ListeChainee() ;
}

public void push(Object obj) {
contenu.addFirst(obj) ;
}

public Object peek() {
return contenu.getFirst() ;
}

public Object pop() {
return contenu.removeFirst() ;
}

public boolean empty() {
return contenu.isEmpty() ;
}

public int size() {
return contenu.size() ;
}

return contenu.toString() ;
}
}
————————–
public class CalculatriceRPN {
private Pile nombres ;
// registre
// (utiles pour simplifier la programmation)
private int r1 ;
private int r2 ;

public CalculatriceRPN() {
nombres=new Pile() ;
}

public void enter(int n) {
// place n au sommet de la pile
nombres.push(new Integer(n)) ;
// affiche la pile
System.out.println(this) ;

e p. 11

}

// met les deux valeurs au sommet de la pile dans r1 et r2
// renvoie true si tout c’est bien passe
private boolean setRegister() {
if (nombres.size()<2) {
System.out.println("??? error ???") ;
return false ;
}
r1=((Integer)nombres.pop()).intValue() ;
r2=((Integer)nombres.pop()).intValue() ;
return true ;
}

// operations arithmetiques

public void add() {
if (setRegister())
enter(r1+r2) ;
}

public void sub() {
if (setRegister())
enter(r1-r2) ;
}

public void times() {
if (setRegister())
enter(r1*r2) ;
}

public void quotient() {
if (setRegister())
enter(r1/r2) ;
}

public void reste() {
if (setRegister())
enter(r1%r2) ;
}

// affiche le contenu de la pile
return nombres.toString() ;
}

// methode utile pour execute
private static boolean isDigit(char c) {
return (’0’<=c && c<=’9’) ;
}

// execution automatique d’une suite d’instructions
// en notation polonaise inversee
public void execute(String s) {
int n=0 ;

e p. 12

char c ;
boolean chiffre=false ;
for (int i=0;i<s.length();i++) {
c=s.charAt(i) ;
if (isDigit(c)) {
n*=10 ;
n+=c-’0’ ;
chiffre=true ;
}
else {
if (chiffre) {
chiffre=false ;
enter(n) ;
n=0 ;
}
if (c==’+’) add() ;
if (c==’-’) sub() ;
if (c==’*’) times() ;
if (c==’/’) quotient() ;
if (c==’%’) reste() ;
}
}
}
}
————————–

Exercice 2.4 :

————————–

Exercice 2.5 :
public class ArbreBinaire {
private Object racine ;
private ArbreBinaire gauche ;
private ArbreBinaire droite ;

public ArbreBinaire(Object etiquette) {
racine=etiquette ;
}

public Object getRacine() {
return racine ;
}

public ArbreBinaire getLeft() {
return gauche ;
}

public ArbreBinaire getRight() {
return droite ;
}

public void setLeft(ArbreBinaire b) {
gauche=b ;

e p. 13

}

public void setRight(ArbreBinaire b) {
droite=b ;
}

public int size() {
int n=1 ;
if (getLeft()!=null) {
n+=getLeft().size() ;
}
if (getRight()!=null) {
n+=getRight().size() ;
}
return n ;
}

public int getHeight() {
int hauteur=0 ;
if (getLeft()!=null) {
hauteur=getLeft().getHeight()+1 ;
}
if (getRight()!=null) {
hauteur=Math.max(hauteur,getRight().getHeight()+1) ;
}
return hauteur ;
}

// remplace l’arbre appelant par l’arbre b
public void setTo(ArbreBinaire b) {
racine=b.racine ;
gauche=b.gauche ;
droite=b.droite ;
}

// methode necessaire pour toString()
private String toString(String decalage) {
String s=decalage+getRacine().toString()+"n" ;
decalage+=’ ’ ;
if (getLeft()!=null)
s+=getLeft().toString(decalage) ;
if (getRight()!=null)
s+=getRight().toString(decalage) ;
return s ;
}

return toString(new String()) ;
}
}
————————–

Exercice 2.6 :
import dauphine.util.* ; // utile pour la saisie des reponses

e p. 14

public class Animals {
private ArbreBinaire cerveau ;

public Animals() {
// question initiale
cerveau=questionTree("est ce un mamifere ?","ours","boa") ;
}

public static ArbreBinaire questionTree(String question,String oui,String non) {
ArbreBinaire q=new ArbreBinaire(question) ;
ArbreBinaire o=new ArbreBinaire(oui) ;
ArbreBinaire n=new ArbreBinaire(non) ;
q.setLeft(o) ;
q.setRight(n) ;
return q ;
}

public static boolean saisieOuiOuNon() {
String reponse ;
do {
System.out.print("oui/non:") ;
reponse=StandardInput.readString() ;
}
while (reponse.charAt(0)!=’o’ && reponse.charAt(0)!=’n’) ;
if (reponse.charAt(0)==’o’) return true ;
else return false ;
}

public void play() {
ArbreBinaire questionsReponses=cerveau ;
while (questionsReponses.size()>1) {
System.out.println(questionsReponses.getRacine()) ;
if (saisieOuiOuNon()) // la reponse est oui
questionsReponses=questionsReponses.getLeft() ;
else
questionsReponses=questionsReponses.getRight() ;
}
String reponseOrdinateur=(String)questionsReponses.getRacine() ;
System.out.println("vous pensez a "+reponseOrdinateur+" ?") ;
if (saisieOuiOuNon()) {
System.out.println("J’AI GAGNE!!!") ;
return ;
}
System.out.println("vous avez gagn´. A quoi pensiez vous ?") ;
e
String reponseCorrecte=StandardInput.readLine() ;
System.out.println("donnez une question dont la re-
ponse sera oui pour "+
reponseCorrecte+" et non pour "+reponseOrdinateur) ;
String question=StandardInput.readLine() ;
questionsReponses.setTo(questionTree(question,reponseCorrecte,
reponseOrdinateur)) ;
}

e p. 15

Animals a=new Animals() ;
StandardInput.startConsole() ;
do {
a.play() ;
System.out.println("voulez vous rejouer ?") ;
}
while (saisieOuiOuNon()) ;
}
}
————————–

3 Remarque sur la classe BufferCanvas
La classe BufferCanvas donné dans l’ńonc´ fonctionne tr`s bien avec Java 2 mais pas du tout avec Java
e e e e
1. Etant donn´ que les ordinateurs du cryo utilisent par d´faut Java 1 voici une programmation simplifié
e e e
de cette classe fonctionnant avec Java 1 (námmoins la classe originale est bien meilleure si vous avez Java
e
2). La classe Viewer reste inchangé.
e
import java.awt.Graphics ;
import java.awt.Image ;
import java.awt.Color ;
import java.awt.Canvas ;
// classe BufferCanvas pour java version 1.1
// l’image n’est plus bufferisee

public class BufferCanvas extends Canvas {
private Graphics graph ;

public BufferCanvas(int largeur,int hauteur) {}

public void initialize() {
graph=this.getGraphics() ;
setColor(Color.black) ;
fillRect(0,0,getWidth(),getHeight()) ;
}

public void update(Graphics g) {
paint(g) ;
}

public void setColor(Color c) {
graph.setColor(c) ;
}

public void drawPixel(int x,int y) {
graph.drawLine(x,y,x,y) ;
}

public void drawString(String s,int x,int y) {
graph.drawString(s,x,y) ;
}

e p. 16

public void drawLine(int x1,int y1,int x2,int y2) {
graph.drawLine(x1,y1,x2,y2) ;
}

public void fillRect(int x1,int y1,int largeur,int hauteur) {
graph.fillRect(x1,y1,largeur,hauteur) ;
}

public void paint(Graphics g) {
}

public void repaint() {
Graphics g=this.getGraphics() ;
paint(g) ;
}
}
————————–

4 Exercices utilisant les graphiques

Exercice 4.1 :
public class Complexe {
private double re ; // partie reelle
private double im ; // partie imaginaire

// constante de classe
public final static Complexe I=new Complexe(0,1) ;

public Complexe() {} // zero

public Complexe(double d) { // nombre r´el
e
re=d ;
im=0 ;
}

public Complexe(double r,double i) {
re=r ;
im=i ;
}

// renvoie la partie reelle
public double getRe() {
return re ;
}

// renvoie la partie imaginaire
public double getIm() {
return im ;
}

// modifie la partie reelle
public void setRe(double d) {

e p. 17

re=d ;
}

// modifie la partie imaginaire
public void setIm(double d) {
im=d ;
}

public Complexe add(Complexe c) { // renvoie this+c
return new Complexe(re+c.re,im+c.im) ;
}

public Complexe times(Complexe c) { // renvoie this*c
return new Complexe(re*c.re-im*c.im,re*c.im+im*c.re) ;
}

public double module() {
return Math.sqrt(re*re+im*im) ;
}

if (obj instanceof Complexe) {
Complexe c=(Complexe)obj ;
return (c.re==re && c.im==im) ;
}
else return false ;
}

return re+"+"+im+"I" ;
}

Complexe c=I ;
System.out.println(c) ;
}
}
————————–
import java.awt.* ;
public class Mandelbrot {
// d´limitations de la partie etudi´e
e ´ e
private Complexe hautGauche=new Complexe(-2.15,1.5) ; // coin haut gauche
private Complexe basDroite=new Complexe(1,-1.5) ; // coin bas droite
// nombre d’iterations maximum
private int maxIterations=32 ;
// seuil pour la divergence
private double seuil=2 ;
// viewer
private Viewer vue ;
private double largeur ;
private double hauteur ;

// complexes utilises dans le calcul
Complexe c=new Complexe() ;

e p. 18

Complexe x=new Complexe() ;

public Mandelbrot(Viewer v) {
vue=v ;
largeur=vue.getLargeur() ;
hauteur=vue.getHauteur() ;
}

public void setHautGauche(Complexe hg) {
hautGauche=hg ;
}

public void setBasDroite(Complexe bd) {
basDroite=bd ;
}

// calcul le nombre complexe correspondant aux
// coordonnees (i,j) sur le Viewer.
// le resultat est place dans c
private void calculParametre(int i,int j) {
c.setRe(hautGauche.getRe()+(i/largeur)*
(basDroite.getRe()-hautGauche.getRe())) ;
c.setIm(hautGauche.getIm()+(j/hauteur)*
(basDroite.getIm()-hautGauche.getIm())) ;
}

// remplace x par x^2+c
// le calcul n’utilise pas les methodes add et times de Complexe
// pour aller plus vite
private void nextX() {
double re=x.getRe() ;
double im=x.getIm() ;
x.setRe(re*re-im*im+c.getRe()) ;
x.setIm(2*re*im+c.getIm()) ;
}

// renvoie le nombre d’it´ration au bout duquel la suite diverge
e
// (x_n>seuil). Si la suite n’a pas diverg´e apr`s maxIt´rations
e e e
// on renvoie -1
public int getDivergence() {
// x0=0
x.setRe(0) ;
x.setIm(0) ;
for (int i=0;i<maxIterations;i++) {
// x->x^2+c
nextX() ;
if (x.module()>seuil)
return i ;
}
return -1 ;
}

public void dessine() {
int iter ;
for(int i=0;i<largeur;i++)

e p. 19

for (int j=0;j<hauteur;j++) {
calculParametre(i,j) ;
iter=getDivergence() ;
vue.setColor(getColor(iter)) ;
vue.drawPixel(i,j) ;
}
vue.repaint() ;
}

private Color getColor(int iter) {
if (iter==-1) return Color.black ;
int red=110-(int)(iter*110.0/maxIterations) ;
int green=red ;
int blue=255 ;
return new Color(red,green,blue) ;
}

Viewer vue=new Viewer(300,300) ;
Mandelbrot m=new Mandelbrot(vue) ;
m.dessine() ;
}
}
————————–

Exercice 4.2 :
import java.awt.* ;
public class Julia {
// d´limitations de la partie etudi´e
e ´ e
private Complexe hautGauche=new Complexe(-1.7,1.5) ; // coin haut gauche
private Complexe basDroite=new Complexe(1.7,-1.5) ; // coin bas droite
// nombre d’iterations maximum
private int maxIterations=128 ;
// seuil pour la divergence
private double seuil=2 ;
// viewer
private double largeur ;
private double hauteur ;

// complexes utilises dans le calcul
Complexe c=new Complexe() ;
Complexe x=new Complexe() ;
Complexe parametre=new Complexe(-0.7795,0.134) ;

public Julia(Viewer v) {
vue=v ;
largeur=vue.getLargeur() ;
hauteur=vue.getHauteur() ;
}

public void setHautGauche(Complexe hg) {
hautGauche=hg ;
}

e p. 20

public void setBasDroite(Complexe bd) {
basDroite=bd ;
}

// calcul le nombre complexe correspondant aux
// coordonnees (i,j) sur le Viewer.
// le resultat est place dans c
private void calculPointCourant(int i,int j) {
c.setRe(hautGauche.getRe()+(i/largeur)*
(basDroite.getRe()-hautGauche.getRe())) ;
c.setIm(hautGauche.getIm()+(j/hauteur)*
(basDroite.getIm()-hautGauche.getIm())) ;
}

// remplace x par x^2+c
// le calcul n’utilise pas les methodes add et times de Complexe
// pour aller plus vite
private void nextX() {
double re=x.getRe() ;
double im=x.getIm() ;
x.setRe(re*re-im*im+parametre.getRe()) ;
x.setIm(2*re*im+parametre.getIm()) ;
}

// renvoie le nombre d’it´ration au bout duquel la suite diverge
e
// (x_n>seuil). Si la suite n’a pas diverg´e apr`s maxIt´rations
e e e
// on renvoie -1
public int getDivergence() {
// x0=c
x.setRe(c.getRe()) ;
x.setIm(c.getIm()) ;
for (int i=0;i<maxIterations;i++) {
// x->x^2+c
nextX() ;
if (x.module()>seuil)
return i ;
}
return -1 ;
}

public void dessine() {
int iter ;
for(int i=0;i<largeur;i++)
for (int j=0;j<hauteur;j++) {
calculPointCourant(i,j) ;
iter=getDivergence() ;
vue.setColor(getColor(iter)) ;
}
vue.repaint() ;
}

private Color getColor(int iter) {
if (iter==-1) return Color.black ;

e p. 21

int red=255-(int)(iter*255.0/maxIterations) ;
int green=red ;
int blue=255 ;
return new Color(red,green,blue) ;
}

Viewer vue=new Viewer(400,400) ;
Julia m=new Julia(vue) ;
m.dessine() ;
}
}
————————–

Exercice 4.3 :

————————–

Exercice 4.4 :
import java.awt.*;
public class PointBrownien {
public int x ;
public int y ;
public static Random alea=new Random((int)System.currentTimeMillis()) ;

public PointBrownien() {
}

public PointBrownien(int a,int b) {
x=a ;
y=b ;
}

public void deplace() {
if (alea.nextDouble()<0.5)
x-- ;
else
x++ ;
if (alea.nextDouble()<0.5)
y-- ;
else
y++ ;
}

if (obj instanceof PointBrownien) {
PointBrownien p=(PointBrownien)obj ;
return (p.x==x && p.y==y) ;
}
return false ;
}


e p. 22

return "("+x+","+y+")" ;
}

int size=500 ;
Viewer v=new Viewer(size,size) ;
v.setColor(new Color(alea.nextInt(255),alea.nextInt(255),
alea.nextInt(255))) ;
PointBrownien p=new PointBrownien(alea.nextInt(size),
alea.nextInt(size)) ;
int n=0 ;
// le point change de couleur et est replace au hazard toutes les
// 1000 iterations
while (true) {
n++ ;
v.drawPixel(p.x,p.y) ;
p.deplace() ;
if (n%1000==0) {
v.setColor(new Color(alea.nextInt(255),alea.nextInt(255),
alea.nextInt(255))) ;
p.x=alea.nextInt(size);
p.y=alea.nextInt(size) ;
}
}
}
}
————————–

Exercice 4.5 :
import java.awt.* ;
public class Boite {
private boolean[][] contenu ;
private int largeur,hauteur ;

public Boite(Viewer v) {
vue=v ;
vue.setColor(Color.red) ;
largeur=v.getLargeur() ;
hauteur=v.getHauteur() ;
contenu=new boolean[largeur][hauteur] ;
for (int i=0;i<largeur;i++)
for (int j=0;j<largeur;j++)
contenu[i][j]=false ;
fixe(largeur/2,hauteur/2) ;
}

public void fixe(int i,int j) {
contenu[i][j]=true ;
}

public boolean estFixe(int i,int j) {
return contenu[i][j] ;

e p. 23

}

public int getLargeur() {
return largeur ;
}

public int getHauteur() {
return hauteur ;
}
}
————————–
import java.awt.* ;
public class Particule {
private PointBrownien pos ;

private static Boite boite=new Boite(new Viewer(200,200)) ;
private static Random alea=new Random((int)System.currentTimeMillis()) ;

public Particule() {
pos=new PointBrownien() ;
}

public void deplace() {
pos.deplace() ;
// univers torique
if (pos.x<=5 || pos.x>=boite.getLargeur()-5 || pos.y<=5 ||
pos.y>boite.getHauteur()-5)
jump() ;
if (estAgrege()) {
boite.fixe(pos.x,pos.y) ;
jump() ;
}
}

// replace la particule au hazard dans la boite
public void jump() {
pos.x=alea.nextInt(boite.getLargeur()-10)+5 ;
pos.y=alea.nextInt(boite.getHauteur()-10)+5 ;
}

public boolean estAgrege() {
for (int i=-1;i<=1;i++)
for (int j=-1;j<=1;j++) {
if (i==0 && j==0) continue ;
if (boite.estFixe(pos.x+i,pos.y+j))
return true ;
}
return false ;
}

Particule diffusion=new Particule() ;
while (true) {

e p. 24

diffusion.deplace() ;
}
}
}
————————–

5 Exercices trait´s en cours
e
Exercice 5.1 :

L’interface Fonction

public interface Fonction {
public double eval(double x) ;
public double max(double a,double b) ;
public double min(double a,double b) ;
}
————————–
public class Lineaire implements Fonction {
private double A,double B ;

public Lineaire(double A,double B) {
this.A=A ; this.B=B ;
}

public double eval(double x) {
return A*x+b ;
}

public double min(double a,double b) {
return Math.min(A*a+B,A*b+B) ;
}

public double max(double a,double b) {
return Math.max(A*a+B,A*b+B) ;
}
}
————————–
public class Sinus implements Fonction {
return Math.sin(x) ;
}

if (a>b) return max(b,a) ;
if ((b-a)>2*Math.PI) return 1 ;
while (a<-3.0/2.0*Math.PI) {
a+=2*Math.PI ;
b+=2*Math.PI ;
}
while (a>=Math.PI/2.0) {
a-=2*Math.PI ;

e p. 25

b-=2*Math.PI ;
}
if (b>Math.PI/2.0) return 1 ;
return Math.max(Math.sin(a),Math.sin(b)) ;
}

if (a>b) return min(b,a) ;
if ((b-a)>2*Math.PI) return -1 ;
while (a<-Math.PI/2.0) {
a+=2*Math.PI ;
b+=2*Math.PI ;
}
while (a>=3.0*Math.PI/2.0) {
a-=2*Math.PI ;
b-=2*Math.PI ;
}
if (b>3*Math.PI/2.0) return -1 ;
return Math.min(Math.sin(a),Math.sin(b)) ;
}
}
————————–
public class Cosinus implements Fonction {
return Math.cos(x) ;
}

return (new Sinus()).max(a+Math.PI/2.0,b+Math.PI/2.0) ;
}

return (new Sinus()).min(a+Math.PI/2.0,b+Math.PI/2.0) ;
}
}
————————–
public class Somme implements Fonction {
private Fonction f,g ;

public Somme(Fonction f,Fonction g) {
f=this.f ; g=this.g ;
}

return f.eval(x)+g.eval(x) ;
}

return f.max(a,b)+g.max(a,b) ;
}

return f.min(a,b)+g.min(a,b) ;

e p. 26

}
}
————————–
public class Produit implements Fonction {
private Fonction f,g ;

public Produit(Fonction f,Fonction g) {
this.f=f ;
this.g=g ;
}

return f.eval(x)*g.eval(x) ;
}

double fmax=f.max() ;
double fmin=f.min() ;
double gmax=g.max() ;
double gmin=g.min() ;
double maxmax=fmax*gmax ;
double maxmin=fmax*gmin ;
double minmax=fmin*gmax ;
double minmin=fmin*gmin ;
double max1=Math.max(maxmax,maxmin) ;
double max2=Math.max(minmax,minmin) ;
return Math.max(max1,max2) ;
}

double fmax=f.max() ;
double fmin=f.min() ;
double gmax=g.max() ;
double gmin=g.min() ;
double min1=Math.min(maxmax,maxmin) ;
double min2=Math.min(minmax,minmin) ;
return Math.max(min1,min2) ;
}
}
————————–
public class Intervale {
private double a,b ;

public Intervale(double x,double y) {
if (x<=y) {
a=x ; b=y ;
}
else {
a=y ; b=x ;

e p. 27

}
}

public double inf() {
return a ;
}

public double sup() {
return b ;
}

public double milieu() {
return (a+b)/2.0 ;
}

public boolean contientZero() {
return (a<=0 && b>=0) ;
}

public Intervale moitieInferieure() {
return new Intervale(a,(a+b)/2.0) ;
}

public Intervale moitieSuperieure() {
return new Intervale((a+b)/2.0,b) ;
}

public Intervale image(Fonction f) {
return new Intervale(f.min(a,b),f.max(a,b)) ;
}
}
————————–
import java.util.* ;
public class AlgoFonction {

public static double[] calculZeros(Fonction f,double a,double b,double precision) {
if (b<a) return calculZeros(f,b,a,precision) ;
Intervale ab=new Intervale(a,b) ;
ArrayList inter=new ArrayList() ;
inter.add(ab) ;
double epsilon=b-a ;
while (epsilon>precision && !inter.isEmpty()) {
epsilon*=0.5 ;
ArrayList temp=new ArrayList() ;
for (int i=0;i<inter.size();i++) {
Intervale inf=((Intervale)inter.get(i)).moitieInferieure() ;
if (inf.image(f).contientZero())
temp.add(inf) ;
Intervale sup=((Intervale)inter.get(i)).moitieSuperieure() ;
if (sup.image(f).contientZero())
temp.add(sup) ;
}
inter=temp ;
}

e p. 28

double[] tab=new double[inter.size()] ;
for (int i=0;i<inter.size();i++) {
tab[i]=((Intervale)inter.get(i)).milieu() ;
System.out.println(tab[i]) ;
}
return tab ;
}
}
————————–
public interface FonctionDerivable extends Fonction {
public FonctionDerivable derive() ;
}
————————–
public class Exponentielle implements FonctionDerivable {
return Math.exp(x) ;
}

if (a<b) return Math.exp(b) ;
return Math.exp(a) ;
}

if (a<b) return Math.exp(a) ;
return Math.exp(b) ;
}

public Fonction derive() {
return new Exponentielle() ;
}
}
————————–
public class SommeDerivable implements FonctionDerivable {
private FonctionDerivable f,g ;

public SommeDerivable(FonctionDerivable f,FonctionDerivable g) {
f=this.f ; g=this.g ;
}

return f.eval(x)+g.eval(x) ;
}

return f.max(a,b)+g.max(a,b) ;
}

return f.min(a,b)+g.min(a,b) ;
}

e p. 29

public FonctionDerivable derive() {
return new SommeDerivable(f.derive(),g.derive()) ;
}
}
————————–
public class ProduitDerivable implements FonctionDerivable {
private FonctionDerivable f,g ;

public ProduitDerivable(FonctionDerivable f,FonctionDerivable g) {
this.f=f ;
this.g=g ;
}

return f.eval(x)*g.eval(x) ;
}

double fmax=f.max(a,b) ;
double fmin=f.min(a,b) ;
double gmax=g.max(a,b) ;
double gmin=g.min(a,b) ;
double max1=Math.max(maxmax,maxmin) ;
double max2=Math.max(minmax,minmin) ;
return Math.max(max1,max2) ;
}

double fmax=f.max(a,b) ;
double fmin=f.min(a,b) ;
double gmax=g.max(a,b) ;
double gmin=g.min(a,b) ;
double min1=Math.min(maxmax,maxmin) ;
double min2=Math.min(minmax,minmin) ;
return Math.max(min1,min2) ;
}

public FonctionDerivable derive() {
return new SommeDerivable(
new ProduitDerivable(f.derive(),g),
new ProduitDerivable(f,g.derive())
) ;
}
}
————————–

e p. 30

Exercice 5.2 :

Analyseur de texte

public class Analyseur {
// analyseur statistique de text

// stats
List listMots ;
List occurences ;
int[] longueurPhrase ;
int nMots ; // nombre de mots dans la phrase analys´e
e
// text
String text ;
int longueur ;
int pos ;

public Analyseur(String text,List listMots,List occurences) {
this.text=text ;
// remise a zero des listes de stockage
listMots.clear() ;
this.listMots=listMots ;
occurences.clear() ;
this.occurences=occurences ;
//
longueur=text.length() ;
pos=0 ;
//
longueurPhrase=new int[20] ;
nMots=0 ;
}

private static boolean isLettreOuChiffre(char c) {
return (’a’ <= c && c<=’z’) || (’A’<=c && c<=’Z’) || (’0’ <= c && c<=’9’) ;
}

private static boolean isSeparateur(char c) {
return (c==’,’ || c==’;’ || c==’:’) ;
}

private static boolean isPoint(char c) {
return (c==’!’ || c==’?’ || c==’!’ || c==’.’) ;
}

private String nextWord() { // mot suivant a partir de pos
`
char c ;
StringBuffer mot=new StringBuffer() ;
while (pos<longueur) {
c=text.charAt(pos) ;
if (isLettreOuChiffre(c)) {
pos++ ;
mot.append(c) ;
}

e p. 31

else {
break ;
}
}
nMots++ ;
return mot.toString() ;
}

private void toNextWord() { // place pos a la position du prochain mot
`
char c ;
int k ;
c=text.charAt(pos) ;
if (isLettreOuChiffre(c)) break ;
if (isPoint(c)) {
k=longueurPhrase[Math.min(19,nMots)] ;
longueurPhrase[Math.min(19,nMots)]=k+1 ;
nMots=0 ;
}
pos++ ;
}
}

public void analyse() {
String temp ;
int k ;
int i ;
temp=nextWord() ;
k=listMots.indexOf(temp) ;
if (k==-1) {
listMots.add(temp) ;
occurences.add(new Integer(1)) ;
}
else {
i=((Integer)occurences.get(k)).intValue()+1 ;
occurences.set(k,new Integer(i)) ;
}
toNextWord() ;
}
}

StringBuffer sb=new StringBuffer() ;
int n=listMots.size() ;
sb.append("Liste des mots: ("+listMots.size()+")"+"n") ;
sb.append("***************n") ;
for (int i=0;i<n;i++) {
if (((Integer)occurences.get(i)).intValue()==1) continue ;
sb.append(listMots.get(i)) ;
sb.append(" ") ;
sb.append(occurences.get(i)) ;
sb.append(’n’) ;
}
sb.append("Stat mots par phrase:n") ;

e p. 32

sb.append("*********************n") ;
for (int i=0;i<longueurPhrase.length;i++) {
sb.append(i+" "+longueurPhrase[i]+"n") ;
}

}

// le texte a analyser est prise en argument de
// la commande d’execution du programme:
// par exemple on tape:
// java Analyseur laclos.txt
// pour analyser le texte appel´ laclos.txt
e
Analyseur stat ;
if (arg.length==0)
stat=new Analyseur(" ",new LinkedList(),new ArrayList()) ;
else
stat=new Analyseur(File.readFile(arg[0]),
new LinkedList(),new ArrayList()) ;
Chronometre c=new Chronometre() ;
c.start() ;
stat.analyse() ;
System.out.println(c.stop()) ;
System.out.println(stat) ;
}
}
————————–

Exercice 5.3 :

Algorithme g´n´tique
e e

public interface Gene {
public void mutation() ;
public Gene dolly() ;
}
————————–
public interface Genome extends Comparable {
public int size() ;
public Gene getGene(int i) ;
public void setGene(int i,Gene g) ;
public void vie() ;
public Genome dolly() ;
}
————————–

/* classe representant une population d’individus avec leurs codes genetiques */

public class Population {
private static Random alea=new Random() ;

e p. 33

private List generation ;

public Population() {
generation=new ArrayList() ;
}

public void add(Genome g) {
generation.add(g) ;
}

public int size() {
return generation.size() ;
}

public Genome getGenome(int i) {
return (Genome)generation.get(i) ;
}

// methode de croisement
// (agit par effet de bord)
public static void croisement(Genome f,Genome g) {
int j=alea.nextInt(f.size()) ;
Gene temp ;
for (int i=j;i<f.size();i++) {
temp=f.getGene(i) ;
f.setGene(i,g.getGene(i)) ;
g.setGene(i,temp) ;
}
}

// methode de mutation
// (agit par effet de bord)
public static void mutation(Genome g) {
for (int i=0;i<g.size();i++)
g.getGene(i).mutation() ;
}

// passage a la generation suivante
public void nextGeneration() {
// evaluation
for (int i=0;i<generation.size();i++)
getGenome(i).vie() ;
// trie
Collections.sort(generation) ;
// selection
List next=new ArrayList() ;
int n=generation.size()/2 ;
for (int i=0;i<n;i++)
next.add(getGenome(i)) ;
// reproduction
Genome f,g ;
for (int i=0;i<n/2;i++) {
f=getGenome(alea.nextInt(n)).dolly() ;
g=getGenome(alea.nextInt(n)).dolly() ;
croisement(f,g) ;

e p. 34

mutation(f) ;
mutation(g) ;
next.add(f) ;
next.add(g) ;
}
generation=next ;
}
}
————————–
public class Lettre implements Gene {
private static Random alea=new Random() ;
private char c ;
double mutationRate=0.02 ;

public Lettre() {
int n=alea.nextInt(’z’-’a’+1) ;
if (n==0)
c=’ ’ ;
else
c=(char)(’a’-1+n) ;
}

private Lettre(char c) {
this.c=c ;
}

public void mutation() {
if (alea.nextDouble()<mutationRate) {
int n=alea.nextInt(’z’-’a’+1) ;
if (n==0)
c=’ ’ ;
else
c=(char)(’a’-1+n) ;
}
}

public Gene dolly() {
return new Lettre(c) ;
}

public char getVal() {
return c ;
}
}
————————–
// classe permettant de deviner une phrase par algo genetique
public class Devine implements Genome {
// devine une phrase de 20 lettres maximum
private static String phrase=new String() ;

private List genes ;

e p. 35

private int score=0 ;

public Devine() {
genes=new ArrayList(20) ;
genes.add(new Lettre()) ;
}

// constructeur de recopie
public Devine(Devine d) {
genes=new ArrayList(20) ;
genes.add(d.getGene(i).dolly()) ;
}

public static void setPhrase(String s) {
phrase=s ;
}

public int size() {
return genes.size() ;
}

public Gene getGene(int i) {
return (Gene)genes.get(i) ;
}

public void setGene(int i,Gene g) {
genes.set(i,g) ;
}

public void vie() {
score=0 ;
for (int i=0;i<Math.min(20,phrase.length());i++)
if (((Lettre)getGene(i)).getVal()==phrase.charAt(i))
score++ ;
System.out.println(this) ;
}

public Genome dolly() {
return new Devine(this) ;
}

public int compareTo(Object o) {
if (!(o instanceof Devine))
return Integer.MIN_VALUE ;
return ((Devine)o).score-score ;
}

String s=score+" " ;
s+=((Lettre)getGene(i)).getVal() ;
return s ;
}

e p. 36

String s="phrase a deviner" ;
Devine.setPhrase(s) ;
Population p=new Population() ;
for (int i=0;i<128;i++)
p.add(new Devine()) ;
for (int i=0;i<150;i++) {
System.out.println("n n n"+i+" n n") ;
p.nextGeneration() ;
}
}
}
————————–

e p. 37

Correction md2 fabien orienté object

Recommandé

Recommandé

Contenu connexe

Tendances

Tendances (20)

En vedette

En vedette (20)

Similaire à Correction md2 fabien orienté object

Similaire à Correction md2 fabien orienté object (17)

Correction md2 fabien orienté object