0e8d557751451b00294592b8a4292333623efbe6
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / scilabTypes / ScilabInteger.java
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2009-2009 - DIGITEO - Antoine ELIAS
4  * 
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  * 
11  */
12
13 package org.scilab.modules.types.scilabTypes;
14
15 import java.util.Arrays;
16
17 /**
18  * This class provides a wrapping on the Scilab Integer datatype
19  */
20 public class ScilabInteger implements ScilabType {
21
22         private Long[][] data;
23         private IntegerType prec;
24         private boolean bUnsigned;
25
26         /**
27          * The different size of the integer type.
28          */
29         public enum IntegerType {
30                 /** Integer of size 8 */
31                 TYPE8,
32                 /** Integer of size 16 */
33                 TYPE16,
34                 /** Integer of size 32 */
35                 TYPE32,
36                 /** Integer of size 64 */
37                 TYPE64
38         }
39         
40         /**
41          * Default constructor
42          */
43         public ScilabInteger() {
44                 data = null;
45         }
46
47         /**
48          * Constructor with values
49          * 
50          * @param data the values
51          * @param bUnsigned true, if the values are unsigned; false if they are signed.
52          */
53         public ScilabInteger(byte[][] data, boolean bUnsigned) {
54                 this.setData(data, bUnsigned);
55         }
56
57         /**
58          * Constructor with values
59          * 
60          * @param data the values
61          * @param bUnsigned true, if the values are unsigned; false if they are signed.
62          */
63         public ScilabInteger(short[][] data, boolean bUnsigned) {
64                 this.setData(data, bUnsigned);
65         }
66
67         /**
68          * Constructor with values
69          * 
70          * @param data the values
71          * @param bUnsigned true, if the values are unsigned; false if they are signed.
72          */
73         public ScilabInteger(int[][] data, boolean bUnsigned) {
74                 this.setData(data, bUnsigned);
75         }
76
77         /**
78          * Constructor with values
79          * 
80          * @param data the values
81          * @param bUnsigned true, if the values are unsigned; false if they are signed.
82          */
83         public ScilabInteger(long[][] data, boolean bUnsigned) {
84                 this.setData(data, bUnsigned);
85         }
86
87         /**
88          * Constructor with single signed value
89          * 
90          * @param value the unique value
91          */
92         public ScilabInteger(byte value) {
93                 this.data = new Long[1][1];
94                 this.data[0][0] = Long.valueOf(value);
95         }
96
97         /**
98          * Constructor with single signed value
99          * 
100          * @param value the unique value
101          */
102         public ScilabInteger(short value) {
103                 this.data = new Long[1][1];
104                 this.data[0][0] = Long.valueOf(value);
105         }
106
107         /**
108          * Constructor with single signed value
109          * 
110          * @param value the unique value
111          */
112         public ScilabInteger(int value) {
113                 this.data = new Long[1][1];
114                 this.data[0][0] = Long.valueOf(value);
115         }
116
117         /**
118          * Constructor with single signed value
119          * 
120          * @param value the unique value
121          */
122         public ScilabInteger(long value) {
123                 this.data = new Long[1][1];
124                 this.data[0][0] = Long.valueOf(value);
125         }
126
127         /**
128          * Set the current values 
129          * 
130          * @param data the values to set
131          * @param bUnsigned true, if these values are unsigned; false otherwise.
132          */
133         public void setData(byte[][] data, boolean bUnsigned) {
134                 this.data = new Long[data.length][data[0].length];
135                 prec = IntegerType.TYPE8;
136                 this.bUnsigned = bUnsigned; 
137                 for (int i = 0; i < data.length; i++) {
138                         for (int j = 0; j < data[0].length; j++) {
139                                 this.data[i][j] = Long.valueOf(data[i][j]);
140                         }
141                 }
142         }
143
144         /**
145          * Set the current values 
146          * 
147          * @param data the values to set
148          * @param bUnsigned true, if these values are unsigned; false otherwise.
149          */
150         public void setData(short[][] data, boolean bUnsigned) {
151                 this.data = new Long[data.length][data[0].length];
152                 prec = IntegerType.TYPE16;
153                 this.bUnsigned = bUnsigned; 
154                 for (int i = 0; i < data.length; i++) {
155                         for (int j = 0; j < data[0].length; j++) {
156                                 this.data[i][j] = Long.valueOf(data[i][j]);
157                         }
158                 }
159         }
160
161         /**
162          * Set the current values 
163          * 
164          * @param data the values to set
165          * @param bUnsigned true, if these values are unsigned; false otherwise.
166          */
167         public void setData(int[][] data, boolean bUnsigned) {
168                 this.data = new Long[data.length][data[0].length];
169                 prec = IntegerType.TYPE32;
170                 this.bUnsigned = bUnsigned; 
171                 for (int i = 0; i < data.length; i++) {
172                         for (int j = 0; j < data[0].length; j++) {
173                                 this.data[i][j] = Long.valueOf(data[i][j]);
174                         }
175                 }
176         }
177
178         /**
179          * Set the current values 
180          * 
181          * @param data the values to set
182          * @param bUnsigned true, if these values are unsigned; false otherwise.
183          */
184         public void setData(long[][] data, boolean bUnsigned) {
185                 this.data = new Long[data.length][data[0].length];
186                 prec = IntegerType.TYPE64;
187                 this.bUnsigned = bUnsigned; 
188                 for (int i = 0; i < data.length; i++) {
189                         for (int j = 0; j < data[0].length; j++) {
190                                 this.data[i][j] = Long.valueOf(data[i][j]);
191                         }
192                 }
193         }
194
195         /**
196          * @return the values
197          */
198         public Long[][] getData() {
199                 return data;
200         }
201         
202
203         /**
204          * Returns the value as the form of short
205          * @return the values as short
206          */
207         public short[][] getDataAsShort() {
208                 short[][] array = new short[this.data.length][this.data[0].length] ;
209                 for (int i = 0; i < data.length; i++) {
210                         for (int j = 0; j < data[0].length; j++) {
211                                 array[i][j]=this.data[i][j].shortValue();
212                         }
213                 }
214                 return array;
215         }
216
217         /**
218          * Returns the value as the form of byte
219          * @return the values as byte
220          */
221         public byte[][] getDataAsByte() {
222                 byte[][] array = new byte[this.data.length][this.data[0].length] ;
223                 for (int i = 0; i < data.length; i++) {
224                         for (int j = 0; j < data[0].length; j++) {
225                                 array[i][j]=this.data[i][j].byteValue();
226                         }
227                 }
228                 return array;
229         }
230
231         /**
232          * Returns the value as the form of int
233          * @return the values as int
234          */
235         public int[][] getDataAsInt() {
236                 int[][] array = new int[this.data.length][this.data[0].length] ;
237                 for (int i = 0; i < data.length; i++) {
238                         for (int j = 0; j < data[0].length; j++) {
239                                 array[i][j]=this.data[i][j].intValue();
240                         }
241                 }
242                 return array;
243         }
244
245         /**
246          * Returns the value as the form of long
247          * Only for Scilab 6.X
248          * @return the values as long
249          */
250         public long[][] getDataAsLong() {
251                 long[][] array = new long[this.data.length][this.data[0].length] ;
252                 for (int i = 0; i < data.length; i++) {
253                         for (int j = 0; j < data[0].length; j++) {
254                                 array[i][j]=this.data[i][j].longValue();
255                         }
256                 }
257                 return array;
258         }
259
260         /**
261          * @return the precision of the values
262          */
263         public IntegerType getPrec() {
264                 return prec;
265         }
266
267         /**
268          * @return true, if the values are signed, false otherwise.
269          */
270         public boolean isUnsigned() {
271                 return bUnsigned;
272         }
273
274         /**
275          * @return the height of the value matrix
276          * @see org.scilab.modules.types.scilabTypes.ScilabType#getHeight()
277          */
278         @Override
279         public int getHeight() {
280                 if (data == null) {
281                         return 0;
282                 }
283                 return data.length;
284         }
285
286         /**
287          * @return the width of the value matrix
288          * @see org.scilab.modules.types.scilabTypes.ScilabType#getWidth()
289          */
290         @Override
291         public int getWidth() {
292                 if (data == null) {
293                         return 0;
294                 }
295                 return data[0].length;
296         }
297
298         // int32(X), int8(x) , int16([x,x,x;x,x,x])
299         //       uint32(X), uint8(x) , uint16([x,x,x;x,x,x])
300         
301         /**
302          * @return true, if there is no values; false otherwise.
303          */
304     public boolean isEmpty() {
305         return (data == null);
306     }
307         
308     /**
309          * @see org.scilab.modules.types.scilabTypes.ScilabType#equals(Object)
310      */
311     public boolean equals(Object obj) {
312         if (obj instanceof ScilabInteger) {
313             return Arrays.deepEquals(this.getData(), ((ScilabInteger)obj).getData());
314         } else {
315             return false;
316         }
317     }
318
319     /**
320      * @return the pretty-printed values 
321      * @see java.lang.Object#toString()
322      */
323     @Override
324         public String toString() {
325         StringBuilder result = new StringBuilder();
326                 
327                 
328                 if (isEmpty()) {
329                         result.append("int([])");
330                         return result.toString();
331                 }
332                 
333                 if (isUnsigned()) {
334                         result.append("u");
335                 }
336                 result.append("int");
337                 
338                 switch (getPrec()) {
339                 case TYPE8:
340                         result.append("8");
341                         break;
342
343                 case TYPE16:
344                         result.append("16");
345                         break;
346                         
347                 case TYPE32:
348                         result.append("32");
349                         break;
350                         
351                 case TYPE64:
352                         result.append("64");
353                         break;
354                         
355                 default:
356                         break;
357                 }
358
359                 result.append("([");
360                 appendData(result);
361                 result.append("])");
362         
363                 return result.toString();
364         }
365
366         /**
367          * Put each value on the buffer.
368          * 
369          * @param result the current buffer
370          */
371         private void appendData(StringBuilder result) {
372                 for (int i = 0; i < getHeight(); ++i) {
373                         for (int j = 0; j < getWidth(); ++j) {
374
375                                 result.append(getData()[i][j]);
376                                 
377                                 
378                                 if (j != getWidth() - 1) {
379                                         result.append(", ");
380                                 }
381                         }
382                         if (i != getHeight() - 1) {
383                                 result.append(" ; ");
384                         }
385                 }
386         }
387         
388 }