Javasci: fix java build, javadoc warnings
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / ScilabBooleanSparse.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.ArrayList;
22 import java.util.Arrays;
23 import java.util.List;
24
25 /**
26  * This class provides a representation on the Scilab Boolean Sparse datatype<br>
27  * <br>
28  * This class is {@link java.io.Serializable} and any modification could impact
29  * load and store of data (Xcos files, Javasci saved data, etc...).<br>
30  * <br>
31  * //TODO Sly : ajouter de la doc
32  *
33  * @see org.scilab.modules.javasci.Scilab
34  */
35 public class ScilabBooleanSparse implements ScilabType {
36
37     private static final long serialVersionUID = 879625048944109684L;
38
39     private static final int VERSION = 0;
40
41     private int rows;
42     private int cols;
43     private int nbItem;
44     private int[] nbItemRow;
45     private int[] colPos;
46     private String varName;
47
48     /**
49      * Default constructor
50      */
51     public ScilabBooleanSparse() {
52     }
53
54     /**
55      * Constructor with a unique value.
56      *
57      * @param data
58      *            the unique value
59      */
60     public ScilabBooleanSparse(boolean data) {
61         if (data) {
62             nbItem = 1;
63             rows = cols = 1;
64             nbItemRow = new int[] { 1 };
65             colPos = new int[] { 0 };
66         }
67     }
68
69     /**
70      * Constructor
71      *
72      * @param rows
73      *            the number of rows
74      * @param cols
75      *            the number of cols
76      * @param nbItem
77      *            the number of true items
78      * @param nbItemRow
79      *            contains the number of true in each rows
80      * @param colPos
81      *            the column position of each true
82      * @param check
83      *            if true the parameters validity is checked
84      * @throws ScilabSparseException if the sparse representation is invalid
85      */
86     public ScilabBooleanSparse(int rows, int cols, int nbItem, int[] nbItemRow, int[] colPos, boolean check) throws ScilabSparseException {
87         this(rows, cols, nbItem, nbItemRow, colPos);
88         if (check) {
89             ScilabSparse.checkValidity(rows, cols, nbItem, nbItemRow, colPos);
90         }
91     }
92
93     /**
94      * Constructor
95      *
96      * @param rows
97      *            the number of rows
98      * @param cols
99      *            the number of cols
100      * @param nbItem
101      *            the number of true items
102      * @param nbItemRow
103      *            contains the number of true in each rows
104      * @param colPos
105      *            the column position of each true
106      */
107     public ScilabBooleanSparse(int rows, int cols, int nbItem, int[] nbItemRow, int[] colPos) {
108         this.rows = rows;
109         this.cols = cols;
110         this.nbItem = nbItem;
111         this.nbItemRow = nbItemRow;
112         this.colPos = colPos;
113     }
114
115     /**
116      * Constructor with a matrix of real data.
117      *
118      * @param data
119      *            the data
120      */
121     public ScilabBooleanSparse(boolean[][] data) {
122         if (data.length != 0 && data[0].length != 0) {
123             rows = data.length;
124             cols = data[0].length;
125             nbItemRow = new int[rows];
126             List<Integer> listCol = new ArrayList<Integer>();
127
128             for (int i = 0; i < rows; i++) {
129                 for (int j = 0; j < cols; j++) {
130                     if (data[i][j]) {
131                         ++nbItem;
132                         ++nbItemRow[i];
133                         listCol.add(j);
134                     }
135                 }
136             }
137
138             colPos = new int[listCol.size()];
139             int i = 0;
140             for (Integer c : listCol) {
141                 colPos[i++] = c;
142             }
143         }
144     }
145
146     /**
147      * Constructor
148      *
149      * @param varName
150      *            the variable name
151      * @param rows
152      *            the number of rows
153      * @param cols
154      *            the number of cols
155      * @param nbItem
156      *            the number of true items
157      * @param nbItemRow
158      *            contains the number of true in each rows
159      * @param colPos
160      *            the column position of each true
161      */
162     public ScilabBooleanSparse(String varName, int rows, int cols, int nbItem, int[] nbItemRow, int[] colPos) {
163         this(rows, cols, nbItem, nbItemRow, colPos);
164         this.varName = varName;
165     }
166
167     /**
168      * {@inheritDoc}
169      */
170     @Override
171     public boolean isReference() {
172         return false;
173     }
174
175     /**
176      * Return the type of Scilab
177      *
178      * @return the type of Scilab
179      * @since 5.4.0
180      */
181     @Override
182     public ScilabTypeEnum getType() {
183         return ScilabTypeEnum.sci_boolean_sparse;
184     }
185
186     /**
187      * Check the emptiness of the associated data.
188      *
189      * @return true, if the associated data array is empty.
190      */
191     @Override
192     public boolean isEmpty() {
193         return rows == 0 && cols == 0;
194     }
195
196     /**
197      * Get the real part of the data.
198      *
199      * @return the real part.
200      */
201     public int getNbNonNullItems() {
202         return nbItem;
203     }
204
205     /**
206      * Set the real part of the data.
207      *
208      * @param nbItem
209      *            the real part.
210      */
211     public void setNbNonNullItems(int nbItem) {
212         this.nbItem = nbItem;
213     }
214
215     /**
216      * Get the real part of the data.
217      *
218      * @return the real part.
219      */
220     public int[] getNbItemRow() {
221         return nbItemRow;
222     }
223
224     /**
225      * Set the real part of the data.
226      *
227      * @param nbItemRow
228      *            the real part.
229      */
230     public void setNbItemRow(int[] nbItemRow) {
231         this.nbItemRow = nbItemRow;
232     }
233
234     /**
235      * Get the column positions of the non null items.
236      *
237      * @return an integer array.
238      */
239     public int[] getScilabColPos() {
240         int[] cp = new int[colPos.length];
241         for (int i = 0; i < colPos.length; i++) {
242             cp[i] = colPos[i] + 1;
243         }
244         return cp;
245     }
246
247     /**
248      * Get the real part of the data.
249      *
250      * @return the real part.
251      */
252     public int[] getColPos() {
253         return colPos;
254     }
255
256     /**
257      * Set the real part of the data.
258      *
259      * @param colPos
260      *            the real part.
261      */
262     public void setColPos(int[] colPos) {
263         this.colPos = colPos;
264     }
265
266     /**
267      * {@inheritDoc}
268      */
269     @Override
270     public String getVarName() {
271         return varName;
272     }
273
274     /**
275      * {@inheritDoc}
276      */
277     @Override
278     public boolean isSwaped() {
279         return false;
280     }
281
282     /**
283      * Get the real part of the full sparse matrix
284      *
285      * @return the full real matrix
286      */
287     public boolean[][] getFullMatrix() {
288         int prev = 0;
289         int j = 0;
290         boolean[][] b = new boolean[rows][cols];
291         for (int i = 0; i < nbItemRow.length; i++) {
292             for (; j < prev + nbItemRow[i]; j++) {
293                 b[i][colPos[j]] = true;
294             }
295             prev += nbItemRow[i];
296         }
297
298         return b;
299     }
300
301     /**
302      * Get complex matrix as a serialized form
303      *
304      * @return the serialized matrix with complex values
305      */
306     // TODO Sly : faire qque chose ici...
307     public boolean[] getSerializedBooleanSparseMatrix() {
308         return new boolean[0];
309     }
310
311     /**
312      * @return the height of the data matrix
313      * @see org.scilab.modules.types.ScilabType#getHeight()
314      */
315     @Override
316     public int getHeight() {
317         return rows;
318     }
319
320     /**
321      * @return the width of the data matrix
322      * @see org.scilab.modules.types.ScilabType#getWidth()
323      */
324     @Override
325     public int getWidth() {
326         return cols;
327     }
328
329
330
331
332     @Override
333     public int hashCode() {
334         final int prime = 31;
335         int result = 1;
336         result = prime * result + Arrays.hashCode(colPos);
337         result = prime * result + cols;
338         result = prime * result + nbItem;
339         result = prime * result + Arrays.hashCode(nbItemRow);
340         result = prime * result + rows;
341         return result;
342     }
343
344     /**
345      * @see org.scilab.modules.types.ScilabType#equals(Object)
346      */
347     @Override
348     public boolean equals(Object obj) {
349         if (obj instanceof ScilabBooleanSparse) {
350             ScilabBooleanSparse sciSparse = (ScilabBooleanSparse) obj;
351             return this.getNbNonNullItems() == sciSparse.getNbNonNullItems() && ScilabSparse.compareNbItemRow(this.getNbItemRow(), sciSparse.getNbItemRow())
352                    && Arrays.equals(this.getColPos(), sciSparse.getColPos());
353         } else {
354             return false;
355         }
356     }
357
358     /**
359      * {@inheritDoc}
360      */
361     @Override
362     public Object getSerializedObject() {
363         return new Object[] { new int[] { rows, cols }, nbItemRow, getScilabColPos() };
364     }
365
366     @Override
367     public void readExternal(ObjectInput in) throws IOException, ClassNotFoundException {
368         int version = in.readInt();
369         switch (version) {
370             case 0:
371                 rows = in.readInt();
372                 cols = in.readInt();
373                 nbItem = in.readInt();
374                 nbItemRow = (int[]) in.readObject();
375                 colPos = (int[]) in.readObject();
376                 varName = (String) in.readObject();
377                 break;
378             default:
379                 throw new ClassNotFoundException("A class ScilabBooleanSparse with a version " + version + " does not exists");
380         }
381     }
382
383     @Override
384     public void writeExternal(ObjectOutput out) throws IOException {
385         out.writeInt(VERSION);
386         out.writeInt(rows);
387         out.writeInt(cols);
388         out.writeInt(nbItem);
389         out.writeObject(nbItemRow);
390         out.writeObject(colPos);
391         out.writeObject(varName);
392     }
393
394     /**
395      * Display the representation in the Scilab language of the type<BR>
396      * Note that the representation can be copied/pasted straight into Scilab
397      *
398      * @return a Scilab-like String representation of the data.
399      * @see java.lang.Object#toString()
400      */
401     @Override
402     public String toString() {
403         StringBuilder result = new StringBuilder();
404
405         if (isEmpty()) {
406             result.append("[]");
407             return result.toString();
408         }
409
410         result.append("sparse([");
411         int j = 0;
412         int prev = 0;
413         for (int i = 0; i < nbItemRow.length; i++) {
414             for (; j < prev + nbItemRow[i]; j++) {
415                 result.append(Integer.toString(i + 1));
416                 result.append(", ");
417                 result.append(Integer.toString(colPos[j] + 1));
418                 if (j < nbItem - 1) {
419                     result.append(" ; ");
420                 }
421             }
422             prev += nbItemRow[i];
423         }
424
425         result.append("], [");
426         for (int i = 0; i < nbItem; i++) {
427             result.append("%t");
428             if (i < nbItem - 1) {
429                 result.append(", ");
430             }
431         }
432
433         result.append("], [");
434         result.append(Integer.toString(rows));
435         result.append(", ");
436         result.append(Integer.toString(cols));
437
438         result.append("])");
439
440         return result.toString();
441     }
442 }