001 /**
002 * <code>Point</code> definit une classe point mathematique dans un
003 * plan qui peut est dans un repere cartesien.<BR>
004 * Un point peut etre translate. Sa distance par rapport a un autre
005 * point peut etre obtenue.
006 *
007 * @author <a href="mailto:garion@isae.fr">Christophe Garion</a>
008 * @version 1.0
009 */
010 class Point {
011 private double x;
012 private double y;
013
014 /**
015 * La valeur servant a comparer des <code>double</code> entre eux.
016 */
017 public static final double EPS = 10E-9;
018
019 /**
020 * Une constante representant le point a l'origine.
021 */
022 public static final Point ORIGINE = new Point(0.0, 0.0);
023
024 /**
025 * Cree une nouvelle instance de <code>Point</code>.
026 *
027 * @param x un <code>double</code> representant l'abscisse du
028 * point a creer
029 * @param y un <code>double</code> representant l'ordonnee du
030 * point a creer
031 */
032 public Point(double x, double y) {
033 this.x = x;
034 this.y = y;
035 }
036
037 /**
038 * La valeur de l'abscisse du point.
039 *
040 * @return un <code>double</code> qui est l'abscisse du point
041 */
042 public double getX() {
043 return this.x;
044 }
045
046 /**
047 * Changer la valeur de l'abscisse du point.
048 *
049 * @param x un <code>double</code> qui est la nouvelle abscisse
050 */
051 public void setX(double x) {
052 this.x = x;
053 }
054
055 /**
056 * La valeur de l'ordonnee du point.
057 *
058 * @return un <code>double</code> qui est l'ordonnee du point
059 */
060 public double getY() {
061 return this.y;
062 }
063
064 /**
065 * Changer la valeur de l'ordonnee du point.
066 *
067 * @param y un <code>double</code> qui est la nouvelle ordonnee
068 */
069 public void setY(double y) {
070 this.y = y;
071 }
072
073 /**
074 * La valeur du module du point.
075 *
076 * @return un <code>double</code> qui est la valeur du module.
077 */
078 public double getModule() {
079 return (Math.sqrt(this.x * this.x + this.y * this.y));
080 }
081
082 /**
083 * Changer la valeur du module du point.
084 *
085 * @param module la nouvelle valeur du module du point. <b>Elle
086 * doit etre positive.</b>
087 */
088 public void setModule(double module) {
089 double ancienModule = getModule();
090
091 if (ancienModule < EPS) {
092 this.x = module;
093 } else {
094 this.x = (this.x * module) / ancienModule;
095 this.y = (this.y * module) / ancienModule;
096 }
097 }
098
099 /**
100 * La valeur de l'argument du point.
101 *
102 * @return un <code>double</code> qui est la valeur de l'argument.
103 */
104 public double getArgument() {
105 if (this.getModule() < EPS) {
106 return 0;
107 }
108
109 double ancienArg = Math.acos(this.x / this.getModule());
110
111 if (this.y < 0) {
112 return (-1.0 * ancienArg);
113 }
114
115 return ancienArg;
116 }
117
118 /**
119 * Changer la valeur de l'argument du point.
120 *
121 * @param argument la nouvelle valeur de l'argument du point.
122 */
123 public void setArgument(double argument) {
124 double ancienModule = this.getModule();
125 x = ancienModule * Math.cos(argument);
126 y = ancienModule * Math.sin(argument);
127 }
128
129 /**
130 * <code>translater</code> permet de translater le point.
131 *
132 * @param dx un <code>double</code> qui represente l'abscisse du
133 * vecteur de translation
134 * @param dy un <code>double</code> qui represente l'ordonnee du
135 * vecteur de translation
136 */
137 public void translater(double dx, double dy) {
138 this.x = this.x + dx;
139 this.y = this.y + dy;
140 }
141
142 /**
143 * <code>afficher</code> permet d'afficher les coordonnees du point.
144 *
145 */
146 public void afficher() {
147 System.out.println(this);
148 }
149
150 /**
151 * <code>toString</code> renvoie un objet de type <code>String</code>
152 * qui represente une chaine de caracteres representant le point.
153 *
154 * <p> Nous verrons plus tard (cf. cours sur l'heritage) que
155 * cette methode nous permet d'utiliser un objet comme un type
156 * primitif et d'ecrire par exemple <code>System.out.println("Le
157 * point est : " + p)</code> ou <code>p</code> est une poignee
158 * sur un objet de type <code>Point</code>.
159 *
160 * @return un objet de type <code>String</code> representant
161 * le point. Pour un point de coordonnees (2,3), cet objet
162 * representera la chaine <code>(2,3)</code>.
163 */
164 public String toString() {
165 return ("(" + this.x + "," + this.y + ")");
166 }
167
168 /**
169 * <code>distance</code> permet de calculer la distance entre deux
170 * points.
171 *
172 * @param p un <code>Point</code> qui est l'autre point pour calculer
173 * la distance
174 * @return un <code>double</code> qui est la distance entre les deux
175 * point
176 */
177 public double distance(Point p) {
178 return (Math.sqrt(((this.x - p.x) * (this.x - p.x)) +
179 ((this.y - p.y) * (this.y - p.y))));
180 }
181
182 /**
183 * <code>equals</code> permet de verifier si deux points sont egaux, i.e.
184 * s'ils ont les memes coordonnees.
185 *
186 * <p> Nous verrons plus tard que cette methode est en fait heritee de la
187 * classe <code>Object</code>
188 *
189 * @param p un <code>Point</code> qui est le point dont on veut verifier s'il
190 * est egal a <code>this</code>
191 * @return un <code>boolean</code> qui est <code>true</code> si les deux
192 * points sont egaux
193 */
194 public boolean equals(Point p) {
195 return (p != null) && (this.x == p.x) && (this.y == p.y);
196 }
197
198 /**
199 * <code>clone</code> permet d'obtenir une copie de <code>this</code>. On obtient
200 * un nouveau point avec des coordonnees identiques.
201 *
202 * <p> Nous verrons plus tard que cette methode est en fait heritee de la
203 * classe <code>Object</code>
204 *
205 * @return un <code>Point p</code> tel que <code>this != p</code> et
206 * <code>this.equals(p)</code>
207 */
208 public Point clone() {
209 return new Point(this.x, this.y);
210 }
211 }
|