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 }