1013eaebfa90c23c56aea1b0a15b4834e211caaa
[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
43         /**
44          * Default constructor
45          */
46         public ScilabDouble() {
47                 realPart = null;
48                 imaginaryPart = null;
49         }
50
51         /**
52          * Constructor with a unique value.
53          * @param data the unique value
54          */
55         public ScilabDouble(double data) {
56                 realPart = new double[1][1];
57                 realPart[0][0] = data;
58                 imaginaryPart = null;
59         }
60
61         /**
62          * Constructor with a unique complex value.
63          * 
64          * @param realData the real part
65          * @param imagData the complex part 
66          */
67         public ScilabDouble(double realData, double imagData) {
68                 realPart = new double[1][1];
69                 realPart[0][0] = realData;
70                 imaginaryPart = new double[1][1];
71                 imaginaryPart[0][0] = imagData;
72         }
73
74         /**
75          * Constructor with a matrix of real data.
76          * 
77          * @param data the data
78          */
79         public ScilabDouble(double[][] data) {
80                 realPart = data;
81                 imaginaryPart = null;
82         }
83
84         /**
85          * Constructor with a matrix of complex numbers 
86          * 
87          * @param realData the real part of the data
88          * @param imagData the imaginary part of the data
89          */
90         public ScilabDouble(double[][] realData, double[][] imagData) {
91                 realPart = realData;
92                 imaginaryPart = imagData;
93         }
94
95         /**
96          * Check the emptiness of the associated data.
97          * @return true, if the associated data array is empty. 
98          */
99         public boolean isEmpty() {
100                 return (realPart == null && imaginaryPart == null);
101         }
102
103         /**
104          * Check if the current data doesn't have an imaginary part.
105          * 
106          * @return true, if the data are real only.
107          */
108         public boolean isReal() {
109                 return (imaginaryPart == null);
110         }
111
112         /**
113          * Get the real part of the data.
114          * 
115          * @return the real part.
116          */
117         public double[][] getRealPart() {
118                 return realPart;
119         }
120
121         /**
122          * Set the real part of the data.
123          * 
124          * @param realPart the real part.
125          */
126         public void setRealPart(double[][] realPart) {
127                 this.realPart = realPart;
128         }
129
130         /**
131          * Get the imaginary part of the data.
132          * 
133          * @return the imaginary part.
134          */
135         public double[][] getImaginaryPart() {
136                 return imaginaryPart;
137         }
138
139         /**
140          * Set the imaginary part of the data.
141          * 
142          * @param imaginaryPart the imaginary part.
143          */
144         public void setImaginaryPart(double[][] imaginaryPart) {
145                 this.imaginaryPart = imaginaryPart;
146         }
147
148
149         /**
150          * Get complex matrix as a serialized form
151          * 
152          * @return the serialized matrix with complex values
153          */
154         public double[] getSerializedComplexMatrix() {
155                 int size = this.getHeight()*this.getWidth();
156                 double [] serializedComplexMatrix = new double[size*2];
157                 for (int i = 0; i < this.getHeight(); i++) {
158                         for (int j = 0; j < this.getWidth(); j++) {
159                                 serializedComplexMatrix[j * this.getHeight() + i] = realPart[i][j];
160                                 serializedComplexMatrix[size+j * this.getHeight() + i] = imaginaryPart[i][j];
161                         }
162                 }
163
164                 return serializedComplexMatrix;
165         }
166
167
168         /**
169          * @return the height of the data matrix
170          * @see org.scilab.modules.types.ScilabType#getHeight()
171          */
172         @Override
173         public int getHeight() {
174                 if (isEmpty()) {
175                         return 0;
176                 }
177                 return realPart.length;
178         }
179
180         /**
181          * @return the width of the data matrix
182          * @see org.scilab.modules.types.ScilabType#getWidth()
183          */
184         @Override
185         public int getWidth() {
186                 if (isEmpty() || realPart.length  == 0) {
187                         return 0;
188                 }
189                 
190                 return realPart[0].length;
191         }
192
193         /**
194          * @see org.scilab.modules.types.ScilabType#equals(Object)
195          */
196         public boolean equals(Object obj) {
197                 if (obj instanceof ScilabDouble) {
198                         ScilabDouble sciDouble = ((ScilabDouble)obj);
199                         if (this.isReal() && sciDouble.isReal()) {
200                                 return Arrays.deepEquals(this.getRealPart(), sciDouble.getRealPart());
201                         } else {
202                                 /* Complex */
203                                 return Arrays.deepEquals(this.getRealPart(), sciDouble.getRealPart()) && Arrays.deepEquals(this.getImaginaryPart(), sciDouble.getImaginaryPart());
204                         }
205                 } else {
206                         return false;
207                 }
208         }
209
210
211         /**
212          * Display the representation in the Scilab language of the type<br />
213          * Note that the representation can be copied/pasted straight into Scilab 
214      *
215          * @return a Scilab-like String representation of the data.
216          * @see java.lang.Object#toString()
217          */
218         @Override
219         public String toString() {
220                 StringBuilder result = new StringBuilder();
221                 
222                 if (isEmpty()) {
223                         result.append("[]");
224                         return result.toString();
225                 }
226
227                 result.append("[");
228                 for (int i = 0; i < getHeight(); ++i) {
229                         for (int j = 0; j < getWidth(); ++j) {
230                                 if (isReal()) {
231                                         result.append(getRealPart()[i][j]);
232                                 } else {
233                                         result.append(getRealPart()[i][j] + " + " + getImaginaryPart()[i][j] + " * %i");
234                                 }
235                                 if (j != getWidth() - 1) {
236                                         result.append(", ");
237                                 }
238                         }
239                         if (i != getHeight() - 1) {
240                                 result.append(" ; ");
241                         }
242                 }
243                 result.append("]");
244                 
245                 return result.toString();
246         }
247
248 }