Javasci: fix java build, javadoc warnings
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / ScilabPolynomial.java
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2011-2011 - DIGITEO - Calixte DENIZET
4  *
5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
6  *
7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
9  * This file was originally licensed under the terms of the CeCILL v2.1,
10  * and continues to be available under such terms.
11  * For more information, see the COPYING file which you should have received
12  * along with this program.
13  *
14  */
15
16 package org.scilab.modules.types;
17
18 import java.io.IOException;
19 import java.io.ObjectInput;
20 import java.io.ObjectOutput;
21 import java.util.Arrays;
22
23 /**
24  * This class provides a representation on the Scilab Polynomial datatype<br>
25  * <br>
26  * This class is {@link java.io.Serializable} and any modification could impact
27  * load and store of data (Xcos files, Javasci saved data, etc...).<br>
28  * <br>
29  * TODO Sly: faire de la doc
30  *
31  * @see org.scilab.modules.javasci.Scilab
32  */
33 public class ScilabPolynomial implements ScilabType {
34
35     private static final long serialVersionUID = 870624048944109684L;
36
37     private static final int VERSION = 0;
38
39     private double[][][] realPart;
40     private double[][][] imaginaryPart;
41
42     private String varName;
43     private String polyVarName = "x";
44     private boolean swaped;
45
46     /**
47      * Default constructor
48      */
49     public ScilabPolynomial() {
50         realPart = null;
51         imaginaryPart = null;
52     }
53
54     /**
55      * Constructor with a unique polynomial.
56      *
57      * @param data
58      *            the unique polynomial
59      */
60     public ScilabPolynomial(double[] data) {
61         realPart = new double[1][1][];
62         realPart[0][0] = data;
63         imaginaryPart = null;
64     }
65
66     /**
67      * Constructor with a unique polynomial.
68      *
69      * @param data
70      *            the unique polynomial
71      * @param polyVarName the polynomial variable name
72      */
73     public ScilabPolynomial(double[] data, String polyVarName) {
74         this(data);
75         setPolyVarName(polyVarName);
76     }
77
78     /**
79      * Constructor with a unique complex polynomial.
80      *
81      * @param realData
82      *            the real part
83      * @param imagData
84      *            the complex part
85      */
86     public ScilabPolynomial(double[] realData, double[] imagData) {
87         realPart = new double[1][1][];
88         realPart[0][0] = realData;
89         imaginaryPart = new double[1][1][];
90         imaginaryPart[0][0] = imagData;
91     }
92
93     /**
94      * Constructor with a unique complex polynomial.
95      *
96      * @param realData
97      *            the real part
98      * @param imagData
99      *            the complex part
100      * @param polyVarName the polynomial variable name
101      */
102     public ScilabPolynomial(double[] realData, double[] imagData, String polyVarName) {
103         this(realData, imagData);
104         setPolyVarName(polyVarName);
105     }
106
107     /**
108      * Constructor with a matrix of real polynomials.
109      *
110      * @param data
111      *            the data
112      */
113     public ScilabPolynomial(double[][][] data) {
114         realPart = data;
115         imaginaryPart = null;
116     }
117
118     /**
119      * Constructor with a matrix of real polynomials.
120      *
121      * @param data
122      *            the data
123      * @param polyVarName the polynomial variable name
124      */
125     public ScilabPolynomial(double[][][] data, String polyVarName) {
126         this(data);
127         setPolyVarName(polyVarName);
128     }
129
130     /**
131      * Constructor with a matrix of complex polynomials
132      *
133      * @param realData
134      *            the real part of the data
135      * @param imagData
136      *            the imaginary part of the data
137      */
138     public ScilabPolynomial(double[][][] realData, double[][][] imagData) {
139         realPart = realData;
140         imaginaryPart = imagData;
141     }
142
143     /**
144      * Constructor with a matrix of complex polynomials
145      *
146      * @param realData
147      *            the real part of the data
148      * @param imagData
149      *            the imaginary part of the data
150      * @param polyVarName the polynomial variable name
151      */
152     public ScilabPolynomial(double[][][] realData, double[][][] imagData, String polyVarName) {
153         this(realData, imagData);
154         setPolyVarName(polyVarName);
155     }
156
157     /**
158      * Constructor with a matrix of complex polynomials
159      *
160      * @param varName
161      *            the variable name
162      * @param polyVarName
163      *            the polynomial variable name
164      * @param realData
165      *            the real part of the data
166      * @param imagData
167      *            the imaginary part of the data
168      * @param swaped
169      *            if true the matrix is stored row by row
170      */
171     public ScilabPolynomial(String varName, String polyVarName, double[][][] realData, double[][][] imagData, boolean swaped) {
172         this.varName = varName;
173         this.polyVarName = polyVarName;
174         this.swaped = swaped;
175         realPart = realData;
176         imaginaryPart = imagData;
177     }
178
179     /**
180      * {@inheritDoc}
181      */
182     @Override
183     public boolean isReference() {
184         return false;
185     }
186
187     /**
188      * Return the type of Scilab
189      *
190      * @return the type of Scilab
191      * @since 5.4.0
192      */
193     @Override
194     public ScilabTypeEnum getType() {
195         return ScilabTypeEnum.sci_poly;
196     }
197
198     /**
199      * Check the emptiness of the associated data.
200      *
201      * @return true, if the associated data array is empty.
202      */
203     @Override
204     public boolean isEmpty() {
205         return (realPart == null && imaginaryPart == null);
206     }
207
208     /**
209      * Check if the current data doesn't have an imaginary part.
210      *
211      * @return true, if the data are real only.
212      */
213     public boolean isReal() {
214         return (imaginaryPart == null);
215     }
216
217     /**
218      * Get the real part of the data.
219      *
220      * @return the real part.
221      */
222     public double[][][] getRealPart() {
223         return realPart;
224     }
225
226     /**
227      * Set the real part of the data.
228      *
229      * @param realPart
230      *            the real part.
231      */
232     public void setRealPart(double[][][] realPart) {
233         this.realPart = realPart;
234     }
235
236     /**
237      * Get the imaginary part of the data.
238      *
239      * @return the imaginary part.
240      */
241     public double[][][] getImaginaryPart() {
242         return imaginaryPart;
243     }
244
245     /**
246      * Set the imaginary part of the data.
247      *
248      * @param imaginaryPart
249      *            the imaginary part.
250      */
251     public void setImaginaryPart(double[][][] imaginaryPart) {
252         this.imaginaryPart = imaginaryPart;
253     }
254
255     /**
256      * Get the polynomila variable name
257      *
258      * @return the name
259      */
260     public String getPolyVarName() {
261         return polyVarName;
262     }
263
264     public void setPolyVarName(String polyVarName) {
265         this.polyVarName = polyVarName;
266     }
267
268     /**
269      * {@inheritDoc}
270      */
271     @Override
272     public String getVarName() {
273         return varName;
274     }
275
276     /**
277      * {@inheritDoc}
278      */
279     @Override
280     public boolean isSwaped() {
281         return swaped;
282     }
283
284     /**
285      * Get complex matrix as a serialized form
286      *
287      * @return the serialized matrix with complex values
288      */
289     // TODO Sly : serializer ce machin
290     public double[][] getSerializedComplexPolynomial() {
291         return new double[0][0];
292     }
293
294     /**
295      * @return the height of the data matrix
296      * @see org.scilab.modules.types.ScilabType#getHeight()
297      */
298     @Override
299     public int getHeight() {
300         if (isEmpty()) {
301             return 0;
302         }
303         return realPart.length;
304     }
305
306     /**
307      * @return the width of the data matrix
308      * @see org.scilab.modules.types.ScilabType#getWidth()
309      */
310     @Override
311     public int getWidth() {
312         if (isEmpty() || realPart.length == 0) {
313             return 0;
314         }
315
316         return realPart[0].length;
317     }
318
319
320     @Override
321     public int hashCode() {
322         final int prime = 31;
323         int result = 1;
324         result = prime * result + Arrays.deepHashCode(imaginaryPart);
325         result = prime * result + ((polyVarName == null) ? 0 : polyVarName.hashCode());
326         result = prime * result + Arrays.deepHashCode(realPart);
327         return result;
328     }
329
330     /**
331      * @see org.scilab.modules.types.ScilabType#equals(Object)
332      */
333     @Override
334     public boolean equals(Object obj) {
335         if (obj instanceof ScilabPolynomial) {
336             ScilabPolynomial sciPoly = ((ScilabPolynomial) obj);
337             if (sciPoly.getPolyVarName().equals(getPolyVarName())) {
338                 if (this.isReal() && sciPoly.isReal()) {
339                     return Arrays.deepEquals(this.getRealPart(), sciPoly.getRealPart());
340                 } else {
341                     /* Complex */
342                     return Arrays.deepEquals(this.getRealPart(), sciPoly.getRealPart())
343                            && Arrays.deepEquals(this.getImaginaryPart(), sciPoly.getImaginaryPart());
344                 }
345             } else {
346                 return false;
347             }
348         } else {
349             return false;
350         }
351     }
352
353     /**
354      * {@inheritDoc}
355      */
356     @Override
357     public Object getSerializedObject() {
358         if (isReal()) {
359             return new Object[] { polyVarName, realPart };
360         } else {
361             return new Object[] { polyVarName, realPart, imaginaryPart };
362         }
363     }
364
365     @Override
366     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
367         int version = in.readInt();
368         switch (version) {
369             case 0:
370                 realPart = (double[][][]) in.readObject();
371                 imaginaryPart = (double[][][]) in.readObject();
372                 varName = (String) in.readObject();
373                 polyVarName = in.readUTF();
374                 swaped = in.readBoolean();
375                 break;
376             default:
377                 throw new ClassNotFoundException("A class ScilabPolynomial with a version " + version + " does not exists");
378         }
379     }
380
381     @Override
382     public void writeExternal(ObjectOutput out) throws IOException {
383         out.writeInt(VERSION);
384         out.writeObject(realPart);
385         out.writeObject(imaginaryPart);
386         out.writeObject(varName);
387         out.writeUTF(polyVarName);
388         out.writeBoolean(swaped);
389     }
390
391     /**
392      * Display the representation in the Scilab language of the type<BR>
393      * Note that the representation can be copied/pasted straight into Scilab
394      *
395      * @return a Scilab-like String representation of the data.
396      * @see java.lang.Object#toString()
397      */
398     @Override
399     public String toString() {
400         StringBuilder result = new StringBuilder();
401
402         if (isEmpty()) {
403             result.append("[]");
404             return result.toString();
405         }
406
407         result.append("[");
408
409         for (int i = 0; i < getHeight(); ++i) {
410             for (int j = 0; j < getWidth(); ++j) {
411                 result.append("poly([");
412                 for (int k = 0; k < realPart[i][j].length; k++) {
413                     if (isReal()) {
414                         result.append(Double.toString(realPart[i][j][k]));
415                     } else {
416                         result.append(Double.toString(realPart[i][j][k]));
417                         if (imaginaryPart[i][j][k] != 0) {
418                             result.append("+");
419                             result.append(Double.toString(imaginaryPart[i][j][k]));
420                             result.append("*%i");
421                         }
422                     }
423                     if (k < realPart[i][j].length - 1) {
424                         result.append(", ");
425                     }
426                 }
427                 result.append("], \"");
428                 result.append(getPolyVarName());
429                 result.append("\", \"coeff\")");
430
431                 if (j < getWidth() - 1) {
432                     result.append(", ");
433                 }
434             }
435             if (i < getHeight() - 1) {
436                 result.append(" ; ");
437             }
438         }
439         result.append("]");
440
441         return result.toString();
442     }
443 }