* Java mapping of Scilab data has now a new method called getType() which
[scilab.git] / scilab / modules / types / src / java / org / scilab / modules / types / ScilabDouble.java
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2009-2009 - DIGITEO - Bruno JOFRET
4  *  Copyright (C) 2010-2010 - DIGITEO - ClĂ©ment DAVID
5  * 
6  *  This file must be used under the terms of the CeCILL.
7  *  This source file is licensed as described in the file COPYING, which
8  *  you should have received as part of this distribution.  The terms
9  *  are also available at
10  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  * 
12  */
13
14 package org.scilab.modules.types;
15
16 import java.util.Arrays;
17
18 /**
19  * This class provides a representation on the Scilab Double datatype<br />
20  * Note that double is the default datatype in Scilab
21  * <br>
22  * Example (real):<br />
23  * <code>
24  * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<br />
25  * ScilabDouble aMatrix = new ScilabDouble(a);<br />
26  * </code>
27  * <br>
28  * Example (complex):<br />
29  * <code>
30  * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<br />
31  * double [][]aImg={{210.2, 220.0, 420.0, 390.0},{230.2, 240.0, 440.0, 400.0}};<br />
32
33  * ScilabDouble aMatrix = new ScilabDouble(a, aImg);
34  * </code>
35  * @see org.scilab.modules.javasci.Scilab
36  */
37 public class ScilabDouble implements ScilabType {
38
39         private static final long serialVersionUID = 879624048944109684L;
40         private double[][] realPart;
41         private double[][] imaginaryPart;
42         private ScilabTypeEnum type = ScilabTypeEnum.sci_matrix;
43
44         /**
45          * Default constructor
46          */
47         public ScilabDouble() {
48                 realPart = null;
49                 imaginaryPart = null;
50         }
51
52         /**
53          * Constructor with a unique value.
54          * @param data the unique value
55          */
56         public ScilabDouble(double data) {
57                 realPart = new double[1][1];
58                 realPart[0][0] = data;
59                 imaginaryPart = null;
60         }
61
62         /**
63          * Constructor with a unique complex value.
64          * 
65          * @param realData the real part
66          * @param imagData the complex part 
67          */
68         public ScilabDouble(double realData, double imagData) {
69                 realPart = new double[1][1];
70                 realPart[0][0] = realData;
71                 imaginaryPart = new double[1][1];
72                 imaginaryPart[0][0] = imagData;
73         }
74
75         /**
76          * Constructor with a matrix of real data.
77          * 
78          * @param data the data
79          */
80         public ScilabDouble(double[][] data) {
81                 realPart = data;
82                 imaginaryPart = null;
83         }
84
85         /**
86          * Constructor with a matrix of complex numbers 
87          * 
88          * @param realData the real part of the data
89          * @param imagData the imaginary part of the data
90          */
91         public ScilabDouble(double[][] realData, double[][] imagData) {
92                 realPart = realData;
93                 imaginaryPart = imagData;
94         }
95
96     /** 
97      * Return the type of Scilab 
98      * @return the type of Scilab
99      * @since 5.4.0
100      */
101     public ScilabTypeEnum getType() {
102         return type;
103     }
104
105         /**
106          * Check the emptiness of the associated data.
107          * @return true, if the associated data array is empty. 
108          */
109         public boolean isEmpty() {
110                 return (realPart == null && imaginaryPart == null);
111         }
112
113         /**
114          * Check if the current data doesn't have an imaginary part.
115          * 
116          * @return true, if the data are real only.
117          */
118         public boolean isReal() {
119                 return (imaginaryPart == null);
120         }
121
122         /**
123          * Get the real part of the data.
124          * 
125          * @return the real part.
126          */
127         public double[][] getRealPart() {
128                 return realPart;
129         }
130
131         /**
132          * Set the real part of the data.
133          * 
134          * @param realPart the real part.
135          */
136         public void setRealPart(double[][] realPart) {
137                 this.realPart = realPart;
138         }
139
140         /**
141          * Get the imaginary part of the data.
142          * 
143          * @return the imaginary part.
144          */
145         public double[][] getImaginaryPart() {
146                 return imaginaryPart;
147         }
148
149         /**
150          * Set the imaginary part of the data.
151          * 
152          * @param imaginaryPart the imaginary part.
153          */
154         public void setImaginaryPart(double[][] imaginaryPart) {
155                 this.imaginaryPart = imaginaryPart;
156         }
157
158
159         /**
160          * Get complex matrix as a serialized form
161          * 
162          * @return the serialized matrix with complex values
163          */
164         public double[] getSerializedComplexMatrix() {
165                 int size = this.getHeight()*this.getWidth();
166                 double [] serializedComplexMatrix = new double[size*2];
167                 for (int i = 0; i < this.getHeight(); i++) {
168                         for (int j = 0; j < this.getWidth(); j++) {
169                                 serializedComplexMatrix[j * this.getHeight() + i] = realPart[i][j];
170                                 serializedComplexMatrix[size+j * this.getHeight() + i] = imaginaryPart[i][j];
171                         }
172                 }
173
174                 return serializedComplexMatrix;
175         }
176
177
178         /**
179          * @return the height of the data matrix
180          * @see org.scilab.modules.types.ScilabType#getHeight()
181          */
182         @Override
183         public int getHeight() {
184                 if (isEmpty()) {
185                         return 0;
186                 }
187                 return realPart.length;
188         }
189
190         /**
191          * @return the width of the data matrix
192          * @see org.scilab.modules.types.ScilabType#getWidth()
193          */
194         @Override
195         public int getWidth() {
196                 if (isEmpty() || realPart.length  == 0) {
197                         return 0;
198                 }
199                 
200                 return realPart[0].length;
201         }
202
203         /**
204          * @see org.scilab.modules.types.ScilabType#equals(Object)
205          */
206         public boolean equals(Object obj) {
207                 if (obj instanceof ScilabDouble) {
208                         ScilabDouble sciDouble = ((ScilabDouble)obj);
209                         if (this.isReal() && sciDouble.isReal()) {
210                                 return Arrays.deepEquals(this.getRealPart(), sciDouble.getRealPart());
211                         } else {
212                                 /* Complex */
213                                 return Arrays.deepEquals(this.getRealPart(), sciDouble.getRealPart()) && Arrays.deepEquals(this.getImaginaryPart(), sciDouble.getImaginaryPart());
214                         }
215                 } else {
216                         return false;
217                 }
218         }
219
220
221         /**
222          * Display the representation in the Scilab language of the type<br />
223          * Note that the representation can be copied/pasted straight into Scilab 
224      *
225          * @return a Scilab-like String representation of the data.
226          * @see java.lang.Object#toString()
227          */
228         @Override
229         public String toString() {
230                 StringBuilder result = new StringBuilder();
231                 
232                 if (isEmpty()) {
233                         result.append("[]");
234                         return result.toString();
235                 }
236
237                 result.append("[");
238                 for (int i = 0; i < getHeight(); ++i) {
239                         for (int j = 0; j < getWidth(); ++j) {
240                                 if (isReal()) {
241                                         result.append(getRealPart()[i][j]);
242                                 } else {
243                                         result.append(getRealPart()[i][j] + " + " + getImaginaryPart()[i][j] + " * %i");
244                                 }
245                                 if (j != getWidth() - 1) {
246                                         result.append(", ");
247                                 }
248                         }
249                         if (i != getHeight() - 1) {
250                                 result.append(" ; ");
251                         }
252                 }
253                 result.append("]");
254                 
255                 return result.toString();
256         }
257
258 }