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