tableau et variable complex

Bonjour à tous,

Je travaille avec un tableau complexe et des variables complexes.

Je ne peux donc pas utiliser les méthodes contains() et length().

Que puis-je utiliser d'autre qui pourrait me rendre les mêmes services svp?

Voici mon code qui ne marche donc pas :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 /** * Méthode vérifiant qu'un complexe est dans le tableau */ public static boolean contientC(complex t[], complex val){ int taille=t.length(); boolean est_dedans=false; int i=0; while(i<taille && !est_dedans){ if(t.contains(new complex(val))); est_dedans=true; i++; } return est_dedans; }
Merci à tous pour votre aide
Bonne soirée
Aud-

Bonjour.
contains ? dans un array ? :koi:
Je ne suis pas sur d'avoir compris ton problème ... mais je suppose que tu veux une sorte de super tableau qui offre la fonctionnalité contains ? si c'est le cas, tu peux utiliser List qui offre cette fonctionnalité.

N.B.: Tu devras redéfinir la méthode equals de ton type Complex pour que containes marche correctement.

Bonne chance

Voici un exemple de la redéfinition de equals() :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
class A{
	private int a;
	private int b;
 
	public A(int _a, int _b){
		a = _a;
		b = _b;
	}
 
	public boolean equals(A obj){
		return (a==obj.a)&&(b==obj.b);
	}
}
 
public class Tester{
	public static void main(String[] args){
		A a = new A(3, 5);
		A aa = new A(3, 5);
 
		System.out.println(a.equals(aa));
	}
}

N.B : tu peux ici récupérer la taille par l'attribut (et non la méthode !) length :

Code:

1
2
int tab[] = new int[10];
int a = tab.length; // 10

Cordialement..

Salut,
Montres nous le code de ta classe Complexe.

classe complexe

Bonjour à tous,

Voici donc le code de la classe complex :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
/**
 * complex  Classe de base pour définir le type "Nb_Complexe" en représentation cartésienne  
 * @author  BAX Olivier et FERE Sébastien (G24  2001-2002) 
 * @version  1.2  17.08.2006 11h45 / HNP  cf. Java 5 
 * @since    1.0  cf. TPP18  2001-2002   (cf. Java 2)
 */
 
//*************************************************************************************
//
//			BIBLIOTHEQUE - NOMBRES COMPLEXES
//
//*************************************************************************************
//
//  Auteurs : BAX Olivier et FERE Sébastien (G24  2001-2002) - MAJ / HNP pour TPP...
//  But : Pouvoir utiliser de manière simple les complexes comme en C++
//
//*************************************************************************************
 
import static java.lang.System.*;  //  pour utiliser 'out' et 'err'  (cf. Java 5)
import static java.lang.Math.*;    //  pour taper les fonctions sans "Math."
 
public class complex   {
	// Couple de variables (attributs privés)
	private double re;			// Partie réelle
	private double im;			// Partie imaginaire
 
 
		// Constructeur 
	complex() {re = 0; im = 0;}			// constructeur vide
	complex(double x, double y) {re = x; im = y;}	// constructeur avec paramètres
 
 
		// Redéfintion des opérateurs
 
	//*************************************************************
	//*  FCT. d'ACCES des Partie réelle et Partie imaginaire      *
	//*************************************************************
	public double getRe() {return re;}	// partie réelle
	public double getIm() {return im;}	// partie imaginaire
 
 
	//************************************************
	//*              Module et Argument              *
	//************************************************	
//	public double mod() {return Math.sqrt(re*re + im*im);}  // cf. Java 2
	public double mod() {return hypot(re, im);}         	// cf. Java 5
 
//	public double arg() {return Math.atan2(re, im);}	// cf. Java 2
	public double arg() {return atan2(re, im);}		// cf. Java 5
	//atan2 : fonction arctan pour un complexe -> couple (double re, double im) 
 
 
	//************************************************
	//*                   Addition                   *
	//************************************************	
	public complex addComplex(complex z)
		{return new complex(re + z.re, im + z.im);}
 
 
	//************************************************
	//*                 Soustraction                 *
	//************************************************	
	public complex subComplex(complex z)
		{return new complex(re - z.re, im - z.im);}
 
 
	//************************************************
	//*                Multiplication                *
	//************************************************		
	public complex multComplex(complex z)
		{return new complex(re*z.re - im*z.im, re*z.im + im*z.re);}
 
 
	//************************************************
	//*                   Division                   *
	//************************************************		
	public complex divComplex(complex z)  {  
		// A NE PAS OUBLIER LE TRAITEMENT DE LA DIV. / 0  CI-DESSOUS !
		double m = z.mod();
		if  (m != 0)
			return new complex( (re*z.re + im*z.im)/(m*m), (im*z.re - re*z.im)/(m*m) );
		else  {
			err.println("Pas de division possible car |z| = 0; ");
			err.println("==>  "+ Double.MAX_VALUE  + " + i*("+ Double.MAX_VALUE + ") est retourn\u00e9 !");
			return new complex(Double.MAX_VALUE  , Double.MAX_VALUE );
		}
	}
 
 
	//************************************************
	//*                 " - " unaire                 *
	//************************************************	
	public complex moinsUnaireComplex()
		{return new complex( -re, -im);}
 
 
 
		// Fonctions d'E/S
 
	//************************************************
	//*       Lecture d'un complexe au clavier       *
	//************************************************		
	public static complex readComplex( char c[])  {  //attention avant il n'y avait pas char c[]!!! mais il me le faut pour le operC() de Chiffre!
 
		out.print("\t\tPartie reelle :     ");	// Partie réelle...
		// instruction d'avant :  double re = keyboard.readDouble();
		double re = Double.parseDouble(es.LireCh());
 
		out.print("\t\tPartie imaginaire : ");	// puis partie imaginaire
		// instruction d'avant :  double im = keyboard.readDouble();
		double im = Double.parseDouble(es.LireCh());
 
		return new complex(re, im);
	}
 
 
	//************************************************
	//*        Affichages d'un nombre complexe       *
	//************************************************	
	public String affComplex()  {
		if( im == 0)		// reel pur
			return " " + re;
		else if( re == 0)	// imaginaire pur
			return "i*(" + im + ")";
		else  {				// complexe quelconque
			if( re > 0 )	// pour l'alignement du texte à l'écran
				return " " + re + " + i*(" + im + ")";
			else
				return re + " + i*(" + im + ")"; // Rappel: i*i=-1
		}
	}
 
	//************************************************
	//*        AUTRES  METHODES - MAJ: 17.08.2006    *
	//************************************************	
 
	public String toString()  {  // Autre méthode d'affichage
	// en  (re-)définissant la méthode 'toString' de la classe 'Object' de Java
		if( im == 0)		// reel pur
			return "  " + re;
		else if( re == 0)	// imaginaire pur
			return "j*(" + im + ")";
		else  {				// complexe quelconque
			if( re > 0 )	// pour l'alignement du texte à l'écran
				return " " + re + " + j*(" + im + ") ";
			else
				return re + " + j*(" + im + ") ";  // Rappel: j*j=-1
		}
	}
 
	public boolean equals(complex obj)  {  // pour tester l'égalité
	// en  (re-)définissant la méthode 'equals' de la classe 'Object' de Java
		return ( re == obj.re  &&  im == obj.im );	
	}
 
	protected complex clone()  throws CloneNotSupportedException  { // copie totale
	// en  (re-)définissant la méthode 'clone' de la classe 'Object' de Java
		return  new  complex(re, im);
	}
 
	protected short compareTo (complex objet)  {
	// pour (re-)définir la méthode 'compareTo' 
		double diff =  mod() - objet.mod();
		if (diff < 0)	return  -1;
		else if (diff > 0)
			return +1;
		else	
			return 0;
	}
 
	public complex conjComplex()  {  
	// pour retourner le conjugué de l'instance courante
		return  new complex(re, -im);
	}
 
	protected void finalize()  throws Throwable  { // destruction par le ramasse-miette 'gc'
	// en  (re-)définissant la méthode 'finalize' de la classe 'Object' de Java
		err.println("Destruction de l'objet : "+ this);
	}
 
}

J'ai deja deux méthodes qui me permettent de vérifier qu'un entier et dant un tableau d'entier et qu'un entier est dans une liste. Voici les codes :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
/**
* Méthode vérifiant qu'un ENTIER est dans le tableau d'ENTIERS
*/
public static boolean contient(int t[], int val){
 
	int taille=t.length;
	boolean est_dedans=false;
	int i=0;
 
	while(i<taille && !est_dedans){
		if(t[i]==val)
			est_dedans=true;
		i++;
	}
 
	return est_dedans;
}
 
 
/**
* Méthode vérifiant qu'un ENTIER est présent dans une LISTE
*/
public static boolean contientL(Vector res, int val){
	int taille=res.size();
	boolean est_dedans=false;
 
	if(res.contains(new Integer(val)))
		est_dedans=true;
 
	return est_dedans;
}

Ce que je cherche à faire c'est donc de vérifier qu'un complexe se trouve bien dans un tableau de complexe, j'ai donc essayé ce code qui bien sur ne marche pas et c'est pour cela que j'ai besoin de votre aide svp :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
/**
* Méthode vérifiant qu'un COMPLEXE est dans le tableau de COMPLEXES
*/
public static boolean contientC(complex t[], complex val){
 
	int taille=t.length();
	boolean est_dedans=false;
	int i=0;
 
	while(i<taille && !est_dedans){
		if(t.contains(new complex(val)));
			est_dedans=true;
		i++;
	}
 
	return est_dedans;
}

Merci par avance à tous
Bonne journée
Aud-

En lisant ton code tu veux pouvoir gérer ou bbine un tableau ou bien une liste. La méthode que tu utilise pour un entier est al bonne, il suffit de al reproduire pour un complexe.
Dans le cas d'un tableau tu parcours les éléments et tu set a vrai si tu tombe sur l'égalité
Dans el cas de la list tu utilise la méthode contains
Le problème dans ton code est le mixe tu défini un tableau et tu utilise la méthode contains
remplace

Code:

if(t.contains(new complex(val)));

par

Code:

if(t[i].equals(val)

t[i]

ok pour le remplacement de la methode contains, mais que faire pour length?

merci pour vos reponces
bonne journée
aud-

Citation:
Envoyé par Chatbour
N.B : tu peux ici récupérer la taille par l'attribut (et non la méthode !) length :
Code:

1 2 int tab[] = new int[10]; int a = tab.length; // 10
Cordialement..

oui j'ai bien vu que tu m'avais donné un tuyau mais ton tableau tab est en int et le mien est en complexe! c'est là tout le problème...

C'est équivalent..

Code:

int taille=t.length;

oui mais non

j'ai le code suivant
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 public static boolean contientC(complex t[], complex val){ int taille=t.length(); boolean est_dedans=false; int i=0; while(i<taille && !est_dedans){ if(t[i].equals(val)); est_dedans=true; i++; } return est_dedans; }
et eclipse me souligne la ligne avec le "length" en me disant :
on ne peut pas utiliser length() sur un tableau de type complex[]

c'est pour ça que j'insiste sur le fait que length() doit être remplacé par qqch pour que ça marche...

merci beaucoup à tous
Aud-

t.length comme attribut et non t.length()..

oups

hi hi toutes mes excuses je n'avais pas vu la différence! :oops::oops::oops:

donc ok c'est tout bon!

merci d'avoir incister sans s'être enervé! c'est cool :lol:

bonne journée
aud-