Institue Polytechnique de Hanoi

*****


Travaux Pratique
Traitement des Signaux Numériques

Nom et Prénom : Lê Minh Việt
Code d’étudiant : 20083132
Filière Francophone en Informatique K53
Professeur : Trịnh Văn Loan



Hà Nội – 2011
Subjet : Soit on a des coefficients de l’équation aux différence. En
utilisant une language programmation en chois sauf matlab, determiner
et dessiner la reponse impulsionnelle du système :





Contenus
I. Théorique : ......................................................................................................... 3
1. L’équation aux differences : .......................................................................... 3
2. Transformation en Z : .................................................................................... 4
3. Transformation en Z inverse : ................................................................... 5
II. L’algorithme et la programme : ...................................................................... 6
1. L’algorithme : ................................................................................................. 6
2. Le programme : .............................................................................................. 7
III. Le résultat : ......................................................................................................12
1. Le programme commence : .........................................................................12



I. Théorique :
1. L’équation aux differences :
Pour un système analogique : la relation entrée – sortie obeit à
l’equation differentielle



Pour un systeme discrètisé : la relation entrée – sortie obéit à
l’équation aux difference


La forme generale :

a
k,
b
k
sont coefficients

Le cas N = 0 : 0
0
( ) ( / ) ( )
M
p
p
y n b a x n p
=
= ÷
¿
En comparant cette relation avec :
( ) ( ) ( )
p
y n h p x n p

=÷·
= ÷
¿
h(n) = b
p
/a
0
pour 0 ≤ n ≤ M
h(n) = 0 partout ailleurs
La duree de la reponse impulsionnelle est finie ( FIR ), le system est
non recursif.
Systeme analogique
X(t)
Y(t)
Systeme discretise
X(t)
Y(t)
Le cas N > 0 :
0 0
( ) ( )
N M
k p
k p
a h n k b n p o
= =
÷ = ÷
¿ ¿
La duree de la reponse impulsionnelle est infinie ( IIR ), le systeme est
recursif => signal sortir depend : signal entrée et signal sortir

Donc si la reponse impulsionnelle est FIR, on remplacer x(n) = δ(n)
Par exemple : y(n) = x(n) – x(n-1) + 5x(n-3)
 h(n) = δ(n) - δ(n-1) - δ(n-3)

Si la reponse impulsionnelle est IIR, donc on transformer y(n) et x(n)
en Z => Y(z) et X(z). Ensuite on calcule H(z) = Y(z)/X(z) et on utilise la
transformation en Z inverse et on a h(n).

2. Transformation en Z :
La transformee en Z d’un signal X(n) est definie par

La fonction de transfert :
( )
( )
( )
Y z
H z
X z
=

On a l’equation aux difference :

0 0
( ) ( )
N M
k p
k p
a y n k b x n p
= =
÷ = ÷
¿ ¿

Apres la transformee en Z :
0 0
( ) ( )
N M
k p
k p
k p
Y z a z X z b z
÷ ÷
= =
=
¿ ¿

Donc on a la transformee en Z de 2 membres :

0
0
( )
( )
( )
M
p
p
p
N
k
k
k
b z
Y z
H z
X z
a z
÷
=
÷
=
= =
¿
¿

H(z) est representee par les zeros et les poles :
1
1
0
1
0
1
(1 )
( )
(1 )
M
p
p
N
k
k
c z
b
H z
a
d z
÷
=
÷
=
÷
=
÷
[
[

3. Transformation en Z inverse :
En appliquant le theoreme de Cauchy :

1 1
1
0 1 2
k
C
k
z dz
k j t
÷
=
¦
=
´
=
¹
}
Ou developper par division :
On exprime :

Ensuite on fait le division de Y(z) par X(z). La suite de coefficients
est h(n)
( ) ( )
n
n
H z h n z

÷
=÷·
=
¿


Par Exemple :

II. L’algorithme et la programme :
1. L’algorithme :
Apres l’entrée, on comparer pour connaitre la reponse impulsionnelle
du systeme est FIR ou IIR.
Si FIR , c’est simplement, pour dessiner on seulement remplacer b
n
et
a
0
pour calculer h(n) du moment n
h(n) = b
n
/a
0
pour 0 ≤ n ≤ M
h(n) = 0 partout ailleurs
Si IIR, on calculer H(z) comme la theorique, et puis, on divise Y(z)
par X(z) comme l’exemple si-dessous :
Y(z)/ X(z) = 1/(1 – 0.64z
-2
)
=> b0 = 1, b1 = 0, b2 = 0
=> a0 = 1, a1 = 0, a2 = -0.64
Order => 0 1 2 3 4 5
b 1 0 0
a 1 0 -0.64
h0 = b0/a0 1
a*h0 1 0 -0.64
b = b – a*h 0 0 0.64
h1 = b1/a0 1 0
a*h1 0 0 0
b = b – a*h 0 0 0.64
h2 = b2/a0 1 0 0.64
a*h2 0 0 0.64 0 -0.64
2

b = b – a*h 0 0 0 0 0.64
2

… … ... … … … ..
Donc on aura :
H(n) = 0.8
n
n paire et n >= 0
H(n) = 0 ailleurs
Alors, quand on a cette formule, c’est simple à dessiner la reponse
impulsionnelle
2. Le programme :
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Lê Minh Việt - Filiere D'Informatique K53 - 19/12/2012
// On a des coefficients de l'equation au difference. En utilisent une language programmation en
chois sauf matlab
// Determiner et Dessiner la reponse impulsionnelle du systeme
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
package reponseimpulsionnelle_designer;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Hàm thư viện
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.util.Scanner;
import javax.swing.JComponent;
import javax.swing.JFrame;
import sun.font.Font2D;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Chương trình
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public class Main {
static String sEquation ;
static String sWarning = " La Reponse Impulsionnelle";
static JFrame jFrame1;
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//Hàm chính
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
public static void main(String[] args) {
// Biến đếm
int i, j;
// Biến ghi số lượng hệ số mỗi bên phương trình
int iN, iM;
// Reset or No
int iReset = 1;
// Điểm bắt đầu
int iStaPoint = 0;
// Mảng lưu kết quả và mảng phụ
float[] h = new float[50];
float[] temp = new float[50];
// Frame vẽ hình
jFrame1 = new JFrame("La reponse Impulsionnelle ");
// Lặp đến khi nào người dùng muốn ngừng
while ( iReset == 1 ) {
for ( i = 0; i < 50; i++ ) {
h[i] = 0;
temp[i] = 0;
}
// Khai báo scanner, nhập đầu vào
Scanner scn = new Scanner (System.in);
System.out.println("La Programme pour designer les reponses impulsionnelles de l'equation
difference");

System.out.println("*****************************************************************
***********************************");
/////////////////////////////////
System.out.print("Il y a combien de coefficient de Y - N = ");
iN = scn.nextInt();
iN--;
/////////////////////////////////
float[] a = new float [iN+1];
for ( i = 0; i < iN+1; i++ )
a[i] = 0;
/////////////////////////////////
for ( i = 0; i <= iN; i++ ) {
System.out.print(" a[" + i +"] est ");
a[i] = scn.nextFloat();
}
/////////////////////////////////
System.out.print("\nIl y a combien de coefficient de X - M = ");
iM = scn.nextInt();
iM--;
/////////////////////////////////
float[] b = new float [50];
for ( i = 0; i < 50; i++ )
b[i] = 0;
/////////////////////////////////
for ( i = 0; i <= iM; i++ ) {
System.out.print(" b[" + i +"] est ");
b[i] = scn.nextFloat();
}
///////////////////////////////////////////////////////////////////////////////////////////////////
// Kiểm tra phần tử đầu tiên != 0
for ( i = 0; i <= iN; i++ ) {
if ( a[i] != 0 ) {
iStaPoint = i;
break;
}
}
/////////////////////////////////
// In ra pt sai phan vua nhap
sEquation = "";
System.out.print("\nL'equation difference : ");
for ( i = 0; i <= iN; i++ ) {
if ( a[i] != 0 ) {
System.out.print(" " + a[i] + "Y(n-" + i + ")");
sEquation += " " + a[i] + "Y(n-" + i + ")";
if ( i != iN ) {
sEquation += " + ";
System.out.print(" + ");
}
}
}
// Nếu ko có hệ số nào => = 0
if ( sEquation == "" ) {
System.out.print(" 0 ");
sEquation = " 0 ";
}
System.out.print(" = ");
sEquation += " = ";
for ( i = 0; i <= iM; i++ ) {
if ( b[i] != 0 ) {
System.out.print(" " + b[i] + "X(n-" + i + ")");
sEquation += " " + b[i] + "X(n-" + i + ")";
if ( i != iM ) {
sEquation += " + ";
System.out.print(" + ");
}
}
}
if ( sEquation.endsWith(" = ") ) {
System.out.print(" 0 ");
sEquation += " 0 ";
}
// Xử lý các trường hợp để tính ra các hệ số của đáp ứng xung
// Trường hợp FIR
if ( iN == 0 ) {
for ( i = 0; i < 50; i++ ) {
if ( i <= iM )
h[i] = b[i]/a[0];
else h[i] = 0;
// System.out.print(" /t"+ h[i]);
}
// Trường hợp IIR
} else if ( iN > 0 ) {
for ( i = 0; i <= 33; i++ ) {
h[i] = b[i]/a[iStaPoint];
for ( j = 0; j < i + iStaPoint; j++ ) {
b[j] = 0;
}
for ( j = i + iStaPoint; j <= iN + i; j++ ) {
temp[j] = h[i]*a[j-i];
b[j] = b[j] - temp[j];
}
}
// for ( i = 0; i < 50; i++ )
// System.out.print("\n"+ h[i]);
}

// Hiện Frame vẽ hình
jFrame1.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
jFrame1.setAlwaysOnTop(true);
jFrame1.setBounds( 300 , 0, 800, 600);

MyCanvas drawCanvas = new MyCanvas();
drawCanvas.repaint();
for ( i = 0; i < 50; i++ ) {
drawCanvas.print[i] = h[i];
}
jFrame1.getContentPane().removeAll();
jFrame1.getContentPane().add(drawCanvas);
jFrame1.setVisible(true);
jFrame1.setResizable(false);
System.out.print("\n Est-ce que vous voulez repartir (1-Oui/0-Non): ");
iReset = scn.nextInt();
}
System.exit(0);
}
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// Class canvas để vẽ hình
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static class MyCanvas extends JComponent {
float[] print = new float[50];
int iTemp, iDistW = 20;
public void paint(Graphics g) {
// Vẽ nền
g.setColor(Color.BLACK);
g.fillRect(0, 0, jFrame1.getWidth(), jFrame1.getHeight());
// Vẽ khung
g.setColor(Color.DARK_GRAY);
for ( int k = 100; k <= 500; k+= 25 )
g.drawLine(60, k, 700, k);
for ( int k = 60; k <= 700; k+= iDistW )
g.drawLine(k, 100, k, 500);
// Vẽ trục hoành
g.setColor(Color.LIGHT_GRAY);
g.fillRect(60, 300, 650, 2);
for ( int k = 60; k <= 700; k+=iDistW ) {
g.fillRect(k-1, 300-1, 4, 4);
}
// Vẽ trục tung
g.fillRect(100, 100, 2, 400 );
for ( int k = 100; k < 500; k+=50 ) {
g.fillRect(100-2, k, 6, 2);
}
for ( int k = 125; k < 500; k+=50 ) {
g.fillRect(100-1, k, 4, 2);
}
// Vẽ phương trình
g.drawString(sEquation, 60, 100 - 20);
g.setColor(Color.RED);
g.drawString(sWarning, 250, 100 - 50);
// Vẽ đáp ứng xung
for ( int k = 0; k <= 600/iDistW; k++ ) {
if( print[k] > 0 ) {
iTemp = (int)(print[k]*50);
g.fillRect( 100 + k*iDistW, 300 - iTemp, 2, iTemp + 2);
g.fillRect( 100 + k*iDistW - 1, 300 - iTemp - 1, 4, 4);
} else if ( print[k] == 0 ) {
g.fillRect( 100 + k*iDistW - 1 , 300 - 1, 4, 4 );
} else if ( print[k] < 0 ) {
iTemp = (int)(Math.abs(print[k])*50);
g.fillRect( 100 + k*iDistW , 300, 2, iTemp + 2);
g.fillRect( 100 + k*iDistW - 1, 300 + iTemp - 1, 4, 4);
}
}
}
}
}


III. Le résultat :
1. Le programme commence :

Dans le premier exemple , on a l’equation aux difference :
Y(n) - 1.414Y(n-1) + Y(n-2) = X(n-1)



Apres l’entrée est suffi, on a le resultat
Si on fait cet exemple manuellement, on peut calculer :
X(0) = 0 X(1) = 1 X(2) = 1.414 X(3) = 1
X(4) = 0 X(5) = -1 X(6) = -1.414 X(7) = -1 …


Le Resultat

Continue

L’equation Y(n) – 0.64Y(n-1) = X(n)
H(n) = 0.8
n
n paire et n >= 0
H(n) = 0 ailleurs


Le resultat




....... determiner et dessiner la reponse impulsionnelle du système : Contenus I.........................................5 II. Le résultat : ............................................................... Le programme commence : ...............................................................................7 III.Subjet : Soit on a des coefficients de l’équation aux différence.......................................6 1....................4 3.............. Transformation en Z inverse : .......................... L’algorithme et la programme : ................................................. L’algorithme : ................. Le programme : ............................................3 1...............................................12 ................................................ Théorique : ............................................................................. En utilisant une language programmation en chois sauf matlab......................................... L’équation aux differences : ................6 2.................12 1...........................3 2................................................ Transformation en Z : ........................................................

Théorique : 1.I. L’équation aux differences : Pour un système analogique : la relation entrée – sortie obeit à l’equation differentielle Systeme analogique X(t) Y(t) Pour un systeme discrètisé : la relation entrée – sortie obéit à l’équation aux difference Systeme discretise X(t) Y(t) La forme generale : ak. . bk sont coefficients Le cas N = 0 : y (n)   (bp / a0 ) x(n  p ) p 0 M En comparant cette relation avec : h(n) = bp/a0 pour 0 ≤ n ≤ M h(n) = 0 partout ailleurs y ( n)  p   h( p ) x ( n  p )  La duree de la reponse impulsionnelle est finie ( FIR ). le system est non recursif.

δ(n-3) Si la reponse impulsionnelle est IIR. 2.Le cas N > 0 :  ak h(n  k )   bp (n  p) k 0 p 0 N M La duree de la reponse impulsionnelle est infinie ( IIR ). donc on transformer y(n) et x(n) en Z => Y(z) et X(z). on remplacer x(n) = δ(n) Par exemple :  y(n) = x(n) – x(n-1) + 5x(n-3) h(n) = δ(n) . Transformation en Z : La transformee en Z d’un signal X(n) est definie par La fonction de transfert : H ( z)  On a l’equation aux difference : Y ( z) X ( z) M a k 0 N k y (n  k )   b p x (n  p ) p 0 N Apres la transformee en Z : Y ( z ) a z k 0 k k  X ( z ) bp z  p p 0 M Donc on a la transformee en Z de 2 membres : . le systeme est recursif => signal sortir depend : signal entrée et signal sortir Donc si la reponse impulsionnelle est FIR. Ensuite on calcule H(z) = Y(z)/X(z) et on utilise la transformation en Z inverse et on a h(n).δ(n-1) .

La suite de coefficients est h(n) H ( z)  Par Exemple : n   h( n) z  n .H ( z)  Y ( z)  X ( z) b z a z k 0 k p 0 N p M p k H(z) est representee par les zeros et les poles : H ( z)  b0 a0  (1  c p 1 N k 1 M p z 1 ) 1  (1  d z k ) 3. Transformation en Z inverse : En appliquant le theoreme de Cauchy : 1 z  k dz    2 j C 0 1 Ou developper par division : On exprime : k 1 k 1 Ensuite on fait le division de Y(z) par X(z).

a1 = 0. a2 = -0.II.64z-2 ) => => b0 = 1.64 . Si FIR . et puis. L’algorithme : Apres l’entrée. pour dessiner on seulement remplacer b n et a0 pour calculer h(n) du moment n h(n) = bn/a0 pour 0 ≤ n ≤ M h(n) = 0 partout ailleurs Si IIR. b2 = 0 a0 = 1. on divise Y(z) par X(z) comme l’exemple si-dessous : Y(z)/ X(z) = 1/(1 – 0. b1 = 0. on calculer H(z) comme la theorique. on comparer pour connaitre la reponse impulsionnelle du systeme est FIR ou IIR. c’est simplement. L’algorithme et la programme : 1.

642 0.64 0. En utilisent une language programmation en chois sauf matlab // Determiner et Dessiner la reponse impulsionnelle du systeme ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// package reponseimpulsionnelle_designer.Filiere D'Informatique K53 . Le programme : ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Lê Minh Việt .8n n paire et n >= 0 H(n) = 0 ailleurs Alors.64 0.Order => b a h0 = b0/a0 a*h0 b = b – a*h h1 = b1/a0 a*h1 b = b – a*h h2 = b2/a0 a*h2 b = b – a*h … Donc on aura : 0 1 1 1 1 0 1 0 0 1 0 0 … 1 0 0 2 0 -0. .. -0..Color.64 0 0.642 … .19/12/2012 // On a des coefficients de l'equation au difference. quand on a cette formule. H(n) = 0. c’est simple à dessiner la reponse impulsionnelle 2.64 0 … 0 0 … -0..64 3 4 5 0 0 0 0 0 0 0 0 .64 0.awt. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Hàm thư viện ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// import java.

float[] temp = new float[50].JComponent. // Reset or No int iReset = 1. System. i < iN+1.Frame. iN--. import java. for ( i = 0. import java. static String sWarning = " La Reponse Impulsionnelle".awt.import java. import javax.swing.nextInt(). } // Khai báo scanner. nhập đầu vào Scanner scn = new Scanner (System.JFrame.out.Graphics. import sun. i++ ) a[i] = 0.awt. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Hàm chính ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public static void main(String[] args) { // Biến đếm int i.font. // Frame vẽ hình jFrame1 = new JFrame("La reponse Impulsionnelle ").println("***************************************************************** ***********************************"). iM. // Lặp đến khi nào người dùng muốn ngừng while ( iReset == 1 ) { for ( i = 0. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //Chương trình ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public class Main { static String sEquation . import javax.Font2D.Scanner.util.print("Il y a combien de coefficient de Y . i++ ) { h[i] = 0. // Điểm bắt đầu int iStaPoint = 0. iN = scn. // Biến ghi số lượng hệ số mỗi bên phương trình int iN. .println("La Programme pour designer les reponses impulsionnelles de l'equation difference").swing.in). System.N = "). j. temp[i] = 0. ///////////////////////////////// float[] a = new float [iN+1]. i < 50. ///////////////////////////////// System.out.out. static JFrame jFrame1. // Mảng lưu kết quả và mảng phụ float[] h = new float[50].

} System. i <= iN.out. } ///////////////////////////////// System.out. System.print("\nL'equation difference : ").out. for ( i = 0. sEquation += " = ". ///////////////////////////////// for ( i = 0. if ( i != iN ) { sEquation += " + ". i <= iN. .print(" " + a[i] + "Y(n-" + i + ")").print("\nIl y a combien de coefficient de X .out.out. for ( i = 0.print(" = "). i++ ) { System. break. i++ ) { System. } /////////////////////////////////////////////////////////////////////////////////////////////////// // Kiểm tra phần tử đầu tiên != 0 for ( i = 0. i++ ) { if ( a[i] != 0 ) { System. i++ ) { if ( a[i] != 0 ) { iStaPoint = i. i <= iM. System. iM--. i <= iN.out.print(" 0 ").print(" " + b[i] + "X(n-" + i + ")").out.nextFloat().///////////////////////////////// for ( i = 0.out.M = "). sEquation = " 0 ". for ( i = 0.print(" + "). i <= iM. } } ///////////////////////////////// // In ra pt sai phan vua nhap sEquation = "". i < 50. i++ ) b[i] = 0. } } } // Nếu ko có hệ số nào => = 0 if ( sEquation == "" ) { System.print(" b[" + i +"] est "). i++ ) { if ( b[i] != 0 ) { System.out.nextInt(). b[i] = scn. a[i] = scn. sEquation += " " + b[i] + "X(n-" + i + ")". iM = scn.nextFloat(). ///////////////////////////////// float[] b = new float [50]. sEquation += " " + a[i] + "Y(n-" + i + ")".print(" a[" + i +"] est ").

if ( i != iM ) { sEquation += " + ".add(drawCanvas).EXIT_ON_CLOSE). } // Xử lý các trường hợp để tính ra các hệ số của đáp ứng xung // Trường hợp FIR if ( iN == 0 ) { for ( i = 0. i < 50.out. for ( i = 0.setBounds( 300 .setResizable(false). jFrame1.print("\n"+ h[i]). // // // . else h[i] = 0. } for ( j = i + iStaPoint. j++ ) { temp[j] = h[i]*a[j-i].print[i] = h[i].out. } // Trường hợp IIR } else if ( iN > 0 ) { for ( i = 0. i++ ) { drawCanvas. i <= 33.out.setAlwaysOnTop(true). } } for ( i = 0. drawCanvas. 600).getContentPane(). sEquation += " 0 ". jFrame1. j <= iN + i.print(" /t"+ h[i]). j++ ) { b[j] = 0. System. jFrame1.setVisible(true).print(" 0 ").print(" + "). MyCanvas drawCanvas = new MyCanvas().repaint(). System. 0.getContentPane(). i++ ) { if ( i <= iM ) h[i] = b[i]/a[0].nextInt().out. j < i + iStaPoint. jFrame1.print("\n Est-ce que vous voulez repartir (1-Oui/0-Non): "). System. for ( j = 0. i < 50. i++ ) { h[i] = b[i]/a[iStaPoint]. b[j] = b[j] . 800. iReset = scn. } jFrame1. jFrame1. } } } if ( sEquation.out. } // Hiện Frame vẽ hình jFrame1. i++ ) System.endsWith(" = ") ) { System.setDefaultCloseOperation(JFrame.temp[j].removeAll(). i < 50.

} ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// // Class canvas để vẽ hình ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////// static class MyCanvas extends JComponent { float[] print = new float[50]. 4).setColor(Color. 4). 700. iTemp + 2).drawString(sWarning. k < 500.drawLine(60.fillRect( 100 + k*iDistW .iTemp. } else if ( print[k] == 0 ) { g. 100.fillRect( 100 + k*iDistW. k+= 25 ) g. k+= iDistW ) g. k. 0. k+=50 ) { g. 2). 100 .RED). 4 ).abs(print[k])*50). g. 400 ). // Vẽ khung g. 300.setColor(Color. // Vẽ đáp ứng xung for ( int k = 0. g. } } . 4. for ( int k = 60.setColor(Color. 300. } // Vẽ trục tung g. 2.20). for ( int k = 100. 300 .1 .1.setColor(Color. 300 + iTemp . 500). public void paint(Graphics g) { // Vẽ nền g.fillRect(100. 4.getWidth(). 250. g.1. for ( int k = 100. g.drawLine(k.50). 2). } // Vẽ phương trình g. iDistW = 20. } else if ( print[k] < 0 ) { iTemp = (int)(Math. k <= 700. g. } for ( int k = 125. k < 500.fillRect(100-2.fillRect(60.LIGHT_GRAY).fillRect( 100 + k*iDistW . 2. 6. for ( int k = 60. iTemp + 2).iTemp . k. 4. g. k++ ) { if( print[k] > 0 ) { iTemp = (int)(print[k]*50). k+=iDistW ) { g. k+=50 ) { g. k <= 500. k.exit(0).fillRect( 100 + k*iDistW . jFrame1. 300 .BLACK).drawString(sEquation.1. 300 .1. k <= 700. 4.fillRect( 100 + k*iDistW .fillRect(100-1. 60. 650. g.DARK_GRAY). jFrame1.} System.fillRect(0. k. 4.fillRect(k-1. 100 . int iTemp.1. k). 100. g. // Vẽ trục hoành g. 300-1. k <= 600/iDistW. 2). 4).getHeight()). 2.

1. Le programme commence : Dans le premier exemple . Le résultat : 1. on a l’equation aux difference : Y(n) .414Y(n-1) + Y(n-2) = X(n-1) .} } } III.

414 X(6) = -1.Apres l’entrée est suffi. on a le resultat Si on fait cet exemple manuellement. on peut calculer : X(0) = 0 X(4) = 0 X(1) = 1 X(5) = -1 X(2) = 1.414 X(3) = 1 X(7) = -1 … .

Le Resultat Continue .

64Y(n-1) = X(n) H(n) = 0.L’equation Y(n) – 0.8n n paire et n >= 0 H(n) = 0 ailleurs .

Le resultat .

Sign up to vote on this title
UsefulNot useful