javasciv2: Double complex matrix management 16/1716/3
Sylvestre Ledru [Fri, 27 Aug 2010 07:31:31 +0000 (09:31 +0200)]
Change-Id: I2a59fa1b9015a8887f9d1500ba204ca620cad778

scilab/modules/javasci/src/c/javasci2_helper.c
scilab/modules/javasci/src/java/org/scilab/modules/javasci/Call_Scilab.java
scilab/modules/javasci/src/java/org/scilab/modules/javasci/Call_ScilabJNI.java
scilab/modules/javasci/src/java/org/scilab/modules/javasci/Scilab.java
scilab/modules/javasci/src/jni/call_scilab.i
scilab/modules/javasci/src/jni/call_scilab_java_typemaps.i
scilab/modules/javasci/src/jni/call_scilab_wrap.c
scilab/modules/javasci/tests/java/org/scilab/tests/modules/javasci/testReadWrite.java
scilab/modules/types/src/java/org/scilab/modules/types/scilabTypes/ScilabDouble.java

index e64dd8e..98c85d1 100644 (file)
 #include "BOOL.h"
 typedef unsigned char byte;
 
+BOOL isComplex(char *variableName) {
+    int iComplex = isNamedVarComplex(pvApiCtx, variableName);
+
+    return iComplex != 0; /* 0 = not complex */
+}
+
 sci_int_types getIntegerPrecision(char* variableName) {
     SciErr sciErr;
 
@@ -93,10 +99,73 @@ int putDouble(char* variableName, double *variable, int *nbRow, int *nbCol) {
         return -1;
     }
     return 0;
+}
+
+
+double * getDoubleComplexReal(char* variableName, int *nbRow, int *nbCol) {
+    SciErr sciErr;
+    double * matrixOfDoubleComplexReal = NULL;
+    double * matrixOfDoubleComplexImg = NULL;
+    sciErr = readNamedComplexMatrixOfDouble(pvApiCtx, variableName, nbRow, nbCol , NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+    }
+
+    /* Alloc the memory */
+    matrixOfDoubleComplexReal=(double*)malloc(((*nbRow)*(*nbCol))*sizeof(double));
+    matrixOfDoubleComplexImg=(double*)malloc(((*nbRow)*(*nbCol))*sizeof(double));
+
+    /* Load the matrix */
+    sciErr = readNamedComplexMatrixOfDouble(pvApiCtx, variableName, nbRow, nbCol, matrixOfDoubleComplexReal, matrixOfDoubleComplexImg);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+    }
+
+    return matrixOfDoubleComplexReal;
+}
+
+double * getDoubleComplexImg(char* variableName, int *nbRow, int *nbCol) {
+    SciErr sciErr;
+    double * matrixOfDoubleComplexReal = NULL;
+    double * matrixOfDoubleComplexImg = NULL;
+    sciErr = readNamedComplexMatrixOfDouble(pvApiCtx, variableName, nbRow, nbCol , NULL, NULL);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+    }
+
+    /* Alloc the memory */
+    matrixOfDoubleComplexReal=(double*)malloc(((*nbRow)*(*nbCol))*sizeof(double));
+    matrixOfDoubleComplexImg=(double*)malloc(((*nbRow)*(*nbCol))*sizeof(double));
+
+    /* Load the matrix */
+    sciErr = readNamedComplexMatrixOfDouble(pvApiCtx, variableName, nbRow, nbCol, matrixOfDoubleComplexReal, matrixOfDoubleComplexImg);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+    }
 
+    return matrixOfDoubleComplexImg;
 
 }
 
+int putDoubleComplex(char* variableName, double *variable, int nbRow, int nbCol) {
+    SciErr sciErr;
+    printf("nbRow / nbCol : %d / %d\n",nbRow, nbCol);fflush(NULL);
+    printf("shift : %d\n",((nbRow)*(nbCol)));fflush(NULL);
+    double *variableImg=variable+((nbRow)*(nbCol));
+    printf("nbRow / nbCol : %d / %d\n",nbRow, nbCol);
+    sciErr = createNamedComplexMatrixOfDouble(pvApiCtx,variableName,nbRow,nbCol, variable, variableImg);
+    if(sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return -1;
+    }
+    return 0;
+}
+
 
 BOOL * getBoolean(char* variableName, int *nbRow, int *nbCol) {
     SciErr sciErr;
@@ -436,3 +505,5 @@ int putUnsignedLong(char* variableName, unsigned long *variable, int *nbRow, int
 
 
 #endif
+
+
index 515243b..d33b35c 100644 (file)
@@ -57,6 +57,14 @@ public class Call_Scilab {
     return ScilabIntegerTypeEnum.swigToEnum(Call_ScilabJNI.getIntegerPrecision(varname));
   }
 
+  public static boolean isComplex(String varname) {
+    return Call_ScilabJNI.isComplex(varname);
+  }
+
+  public static int putDoubleComplex(String variableName, double[] variable, int nbRow, int nbCol) {
+    return Call_ScilabJNI.putDoubleComplex(variableName, variable, nbRow, nbCol);
+  }
+
   public static double[][] getDouble(String variableName) {
     return Call_ScilabJNI.getDouble(variableName);
   }
@@ -73,10 +81,6 @@ public class Call_Scilab {
     return Call_ScilabJNI.putBoolean(variableName, variable);
   }
 
-  public static int putDoubleComplex(String variableName, double[][] variable, double[][] variableImg, int nbRow, int nbCol) {
-    return Call_ScilabJNI.putDoubleComplex(variableName, variable, variableImg, nbRow, nbCol);
-  }
-
   public static byte[][] getByte(String variableName) {
     return Call_ScilabJNI.getByte(variableName);
   }
@@ -125,4 +129,12 @@ public class Call_Scilab {
     return Call_ScilabJNI.putUnsignedInt(variableName, variable);
   }
 
+  public static double[][] getDoubleComplexReal(String variableName) {
+    return Call_ScilabJNI.getDoubleComplexReal(variableName);
+  }
+
+  public static double[][] getDoubleComplexImg(String variableName) {
+    return Call_ScilabJNI.getDoubleComplexImg(variableName);
+  }
+
 }
index e73c4dc..b38fdcc 100644 (file)
@@ -46,11 +46,12 @@ class Call_ScilabJNI {
   public final static native int GetLastErrorCode();
   public final static native int getVariableType(String jarg1);
   public final static native int getIntegerPrecision(String jarg1);
+  public final static native boolean isComplex(String jarg1);
+  public final static native int putDoubleComplex(String jarg1, double[] jarg2, int jarg3, int jarg4);
   public final static native double[][] getDouble(String jarg1);
   public final static native int putDouble(String jarg1, double[][] jarg2);
   public final static native boolean[][] getBoolean(String jarg1);
   public final static native int putBoolean(String jarg1, boolean[][] jarg2);
-  public final static native int putDoubleComplex(String jarg1, double[][] jarg2, double[][] jarg3, int jarg4, int jarg5);
   public final static native byte[][] getByte(String jarg1);
   public final static native int putByte(String jarg1, byte[][] jarg2);
   public final static native byte[][] getUnsignedByte(String jarg1);
@@ -63,4 +64,6 @@ class Call_ScilabJNI {
   public final static native int putInt(String jarg1, int[][] jarg2);
   public final static native int[][] getUnsignedInt(String jarg1);
   public final static native int putUnsignedInt(String jarg1, int[][] jarg2);
+  public final static native double[][] getDoubleComplexReal(String jarg1);
+  public final static native double[][] getDoubleComplexImg(String jarg1);
 }
index 81a0808..0936319 100644 (file)
@@ -197,7 +197,6 @@ public class Scilab {
      */
     public boolean close() {
                boolean res = Call_Scilab.TerminateScilab(null);
-               System.err.println("Call_Scilab.TerminateScilab(null);"+res);
         return res;
     }
 
@@ -246,13 +245,7 @@ public class Scilab {
             System.err.println("Could not find variable type: " + e.getLocalizedMessage());
         }
 
-//        ScilabTypeEnum typeEnum = ScilabTypeEnum.swigToEnum(variableType);
         return variableType;
-        
-//        return typeEnum;
-
-//        int varType = 
-//        System.out.println(ScilabTypeEnum(varType));
 
     }
 
@@ -269,7 +262,11 @@ public class Scilab {
                ScilabTypeEnum sciType = this.getVariableType(varname);
                switch (sciType) {
                        case sci_matrix:
-                               return new ScilabDouble(Call_Scilab.getDouble(varname));
+                if (!Call_Scilab.isComplex(varname)) {
+                    return new ScilabDouble(Call_Scilab.getDouble(varname));
+                } else {
+                    return new ScilabDouble(Call_Scilab.getDoubleComplexReal(varname), Call_Scilab.getDoubleComplexImg(varname));
+                }
                        case sci_boolean:
                                return new ScilabBoolean(Call_Scilab.getBoolean(varname));
                        case sci_ints:
@@ -290,6 +287,7 @@ public class Scilab {
                                                return new ScilabInteger(Call_Scilab.getUnsignedInt(varname), true);
                                        case sci_int64:
                                        case sci_uint64:
+//     throw new UnsupportedTypeException();
                                                // Unspported operation
                                                // will be available in Scilab 6
                                                // Type = long
@@ -310,13 +308,16 @@ public class Scilab {
      * @return if the operation is successful
     */
     public boolean put(String varname, ScilabType theVariable) {
-               int err = -1;
+               int err = -999;
         if (theVariable instanceof ScilabDouble) {
             ScilabDouble sciDouble = (ScilabDouble)theVariable;
             if (sciDouble.isReal()) {
                                err = Call_Scilab.putDouble(varname, sciDouble.getRealPart());
             } else {
-                               //                Call_Scilab.putDoubleComplex(varname,sciDouble.getRealPart(), sciDouble.getImaginaryPart());
+// Special case. Serialize the matrix from Scilab same way Scilab stores them
+// (columns by columns)
+// plus the complex values at the second part of the array
+                err = Call_Scilab.putDoubleComplex(varname,sciDouble.getSerializedComplexMatrix(), sciDouble.getHeight(), sciDouble.getWidth());
             }
                }
                if (theVariable instanceof ScilabInteger) {
@@ -355,11 +356,16 @@ public class Scilab {
         }
                //TODO: a remplacer par la bonne exception return new UnsupportedTypeException();
                //              throw new UnsupportedTypeException();
-
-               if (err != 0) {
-                       // Exception a lancer
-                       System.err.println("put failed");
-               }
+        if (err == -999) {
+                // Exception a lancer
+
+            System.err.println("Type not managed: " + theVariable.getClass());
+        } else {
+            if (err != 0) {
+                // Exception a lancer
+                System.err.println("put failed");
+            }
+        }
 
                return true;
     }
index cc05a48..eacb7bd 100644 (file)
@@ -92,8 +92,7 @@ public class";
 #endif
 
 
-//BOOL StartScilab(char *SCIpath, char *ScilabStartup, int *Stacksize);
-int Call_ScilabOpen (char* SCIpath, char *ScilabStartup, int *Stacksize);
+int Call_ScilabOpen(char* SCIpath, char *ScilabStartup, int *Stacksize);
 
 BOOL TerminateScilab(char *ScilabQuit);
 
@@ -105,29 +104,29 @@ int ScilabHaveAGraph(void);
 
 int GetLastErrorCode(void);
 
-//int getVariableType(char *varname);
-
 sci_types getVariableType(char *varname);
 
 sci_int_types getIntegerPrecision(char* varname);
 
-//int putInteger(char *varname, int variable[][]);
+BOOL isComplex(char* varname);
+
+%include "arrays_java.i"
+int putDoubleComplex(char * variableName, double variable[], int nbRow, int nbCol);
 
-//int putInteger(char * variableName, int **variable, int nbRow, int nbCol);
 
 // This position matters. It will apply only to the following lines
 %include "call_scilab_java_typemaps.i"
 
-double * getDouble(char *variableName, int *nbRow, int *nbCol);
 
+// double (default Scilab type)
+double * getDouble(char *variableName, int *nbRow, int *nbCol);
 int putDouble(char * variableName, double variable[], int nbRow, int nbCol);
 
-BOOL * getBoolean(char *variableName, int *nbRow, int *nbCol);
 
+// boolean (%t / %f)
+BOOL * getBoolean(char *variableName, int *nbRow, int *nbCol);
 int putBoolean(char * variableName, BOOL variable[], int nbRow, int nbCol);
 
-int putDoubleComplex(char * variableName, double variable[], double variableImg[], int nbRow, int nbCol);
-
 %inline %{
 typedef unsigned char byte;
 %}
@@ -161,3 +160,8 @@ int putLong(char * variableName, long variable[], int nbRow, int nbCol);
 unsigned long * getUnsignedLong(char *variableName, int *nbRow, int *nbCol);
 int putUnsignedLong(char * variableName, unsigned long variable[], int nbRow, int nbCol);
 #endif
+
+%include "call_scilab_java_typemaps_complex.i"
+// Complex
+double * getDoubleComplexReal(char *variableName, int *nbRow, int *nbCol);
+double * getDoubleComplexImg(char * variableName, int *nbRow, int *nbCol);
index 24d7b31..61d39c3 100644 (file)
@@ -115,14 +115,12 @@ matching in Java */
 
 }
 %enddef
-// je fais mal les regles pour chopper les profiles 
 
-// See swig documentation for the full list:
+// See SWIG documentation for the full list:
 // http://www.swig.org/Doc1.3/Java.html#default_primitive_type_mappings
 
 // Scilab: int8
 JAVASCI_ARRAYS_IMPL(byte, jbyte, Byte, byte, "[B")     /* signed char[] */
-//JAVASCI_ARRAYS_IMPL(char, jshort, Short, unsigned char, "[C") /* unsigned char[] */
 JAVASCI_ARRAYS_IMPL(unsigned char, jshort, Short, jshort, "[C") /* unsigned char */
 
 // Scilab: int16
index 06c42fa..746ba2b 100644 (file)
@@ -849,12 +849,12 @@ SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScil
   {
     int i = 0;
     size1 = (*jenv)->GetArrayLength(jenv, jarg1);
-    arg1 = (char **) malloc((size1+1)*sizeof(char *));
+    arg1 = (char **) MALLOC((size1+1)*sizeof(char *));
     /* make a copy of each string */
     for (i = 0; i<size1; i++) {
       jstring j_string = (jstring)(*jenv)->GetObjectArrayElement(jenv, jarg1, i);
       const char * c_string = (*jenv)->GetStringUTFChars(jenv, j_string, 0);
-      arg1[i] = malloc((strlen(c_string)+1)*sizeof(const char *));
+      arg1[i] = MALLOC((strlen(c_string)+1)*sizeof(const char *));
       strcpy(arg1[i], c_string);
       (*jenv)->ReleaseStringUTFChars(jenv, j_string, c_string);
       (*jenv)->DeleteLocalRef(jenv, j_string);
@@ -867,8 +867,8 @@ SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_SendScil
   {
     int i;
     for (i=0; i<size1-1; i++)
-    free(arg1[i]);
-    free(arg1);
+    FREE(arg1[i]);
+    FREE(arg1);
   }
   return jresult;
 }
@@ -936,6 +936,56 @@ SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getInteg
 }
 
 
+SWIGEXPORT jboolean JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_isComplex(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jboolean jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  BOOL result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  result = isComplex(arg1);
+  {
+    if (result) jresult = JNI_TRUE   ;
+    else  jresult = JNI_FALSE   ;
+  }
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  return jresult;
+}
+
+
+SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDoubleComplex(JNIEnv *jenv, jclass jcls, jstring jarg1, jdoubleArray jarg2, jint jarg3, jint jarg4) {
+  jint jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  double *arg2 ;
+  int arg3 ;
+  int arg4 ;
+  jdouble *jarr2 ;
+  int result;
+  
+  (void)jenv;
+  (void)jcls;
+  arg1 = 0;
+  if (jarg1) {
+    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+    if (!arg1) return 0;
+  }
+  if (!SWIG_JavaArrayInDouble(jenv, &jarr2, &arg2, jarg2)) return 0; 
+  arg3 = (int)jarg3; 
+  arg4 = (int)jarg4; 
+  result = (int)putDoubleComplex(arg1,arg2,arg3,arg4);
+  jresult = (jint)result; 
+  SWIG_JavaArrayArgoutDouble(jenv, jarr2, arg2, jarg2); 
+  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+  free(arg2); 
+  return jresult;
+}
+
+
 SWIGEXPORT jobjectArray JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getDouble(JNIEnv *jenv, jclass jcls, jstring jarg1) {
   jobjectArray jresult = 0 ;
   char *arg1 = (char *) 0 ;
@@ -1138,39 +1188,6 @@ SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putBoole
 }
 
 
-SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putDoubleComplex(JNIEnv *jenv, jclass jcls, jstring jarg1, jobjectArray jarg2, jobjectArray jarg3, jint jarg4, jint jarg5) {
-  jint jresult = 0 ;
-  char *arg1 = (char *) 0 ;
-  double *arg2 ;
-  double *arg3 ;
-  int arg4 ;
-  int arg5 ;
-  jdouble *jarr2 ;
-  jdouble *jarr3 ;
-  int result;
-  
-  (void)jenv;
-  (void)jcls;
-  arg1 = 0;
-  if (jarg1) {
-    arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
-    if (!arg1) return 0;
-  }
-  if (!SWIG_JavaArrayInDouble(jenv, &jarr2, &arg2, jarg2)) return 0; 
-  if (!SWIG_JavaArrayInDouble(jenv, &jarr3, &arg3, jarg3)) return 0; 
-  arg4 = (int)jarg4; 
-  arg5 = (int)jarg5; 
-  result = (int)putDoubleComplex(arg1,arg2,arg3,arg4,arg5);
-  jresult = (jint)result; 
-  SWIG_JavaArrayArgoutDouble(jenv, jarr2, arg2, jarg2);// 
-  SWIG_JavaArrayArgoutDouble(jenv, jarr3, arg3, jarg3);// 
-  if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
-  free(arg2); 
-  free(arg3); 
-  return jresult;
-}
-
-
 SWIGEXPORT jobjectArray JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getByte(JNIEnv *jenv, jclass jcls, jstring jarg1) {
   jobjectArray jresult = 0 ;
   char *arg1 = (char *) 0 ;
@@ -1777,6 +1794,118 @@ SWIGEXPORT jint JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_putUnsig
 }
 
 
+SWIGEXPORT jobjectArray JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getDoubleComplexReal(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jobjectArray jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int *arg3 = (int *) 0 ;
+  int nbRow ;
+  int nbCol ;
+  double *result = 0 ;
+  
+  (void)jenv;
+  (void)jcls;
+  {
+    arg2 = &nbRow;
+    arg3 = &nbCol;
+    arg1 = 0;
+    if (jarg1) {
+      arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+      if (!arg1) return 0;
+    }
+  }
+  result = (double *)getDoubleComplexReal(arg1,arg2,arg3);
+  {
+    jclass doubleArr = (*jenv)->FindClass(jenv, "[D");
+    int i,j;
+    jresult = (*jenv)->NewObjectArray(jenv, nbRow,doubleArr, NULL);
+    
+    for (i=0; i < nbRow; i++) {
+      jdouble array[nbCol];
+      jdoubleArray jarray = (*jenv)->NewDoubleArray(jenv, nbCol);
+      if (jarray == NULL) {
+        printf("Could not allocate\n");fflush(NULL);
+      }
+      
+      for (j=0; j < nbCol; j++) {
+        /* Scilab is storing matrice cols by cols while Java is doing it
+                       row by row. Therefor, we need to convert it */
+        array[j]=result[nbRow*j+i];
+      }
+      
+      (*jenv)->SetDoubleArrayRegion(jenv, jarray, 0, nbCol, array);
+      
+      (*jenv)->SetObjectArrayElement(jenv, jresult, i, jarray);
+      
+      (*jenv)->DeleteLocalRef(jenv, jarray);
+      
+    }
+    
+    
+    if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+    free(result);
+    
+  }
+  return jresult;
+}
+
+
+SWIGEXPORT jobjectArray JNICALL Java_org_scilab_modules_javasci_Call_1ScilabJNI_getDoubleComplexImg(JNIEnv *jenv, jclass jcls, jstring jarg1) {
+  jobjectArray jresult = 0 ;
+  char *arg1 = (char *) 0 ;
+  int *arg2 = (int *) 0 ;
+  int *arg3 = (int *) 0 ;
+  int nbRow ;
+  int nbCol ;
+  double *result = 0 ;
+  
+  (void)jenv;
+  (void)jcls;
+  {
+    arg2 = &nbRow;
+    arg3 = &nbCol;
+    arg1 = 0;
+    if (jarg1) {
+      arg1 = (char *)(*jenv)->GetStringUTFChars(jenv, jarg1, 0);
+      if (!arg1) return 0;
+    }
+  }
+  result = (double *)getDoubleComplexImg(arg1,arg2,arg3);
+  {
+    jclass doubleArr = (*jenv)->FindClass(jenv, "[D");
+    int i,j;
+    jresult = (*jenv)->NewObjectArray(jenv, nbRow,doubleArr, NULL);
+    
+    for (i=0; i < nbRow; i++) {
+      jdouble array[nbCol];
+      jdoubleArray jarray = (*jenv)->NewDoubleArray(jenv, nbCol);
+      if (jarray == NULL) {
+        printf("Could not allocate\n");fflush(NULL);
+      }
+      
+      for (j=0; j < nbCol; j++) {
+        /* Scilab is storing matrice cols by cols while Java is doing it
+                       row by row. Therefor, we need to convert it */
+        array[j]=result[nbRow*j+i];
+      }
+      
+      (*jenv)->SetDoubleArrayRegion(jenv, jarray, 0, nbCol, array);
+      
+      (*jenv)->SetObjectArrayElement(jenv, jresult, i, jarray);
+      
+      (*jenv)->DeleteLocalRef(jenv, jarray);
+      
+    }
+    
+    
+    if (arg1) (*jenv)->ReleaseStringUTFChars(jenv, jarg1, (const char *)arg1);
+    free(result);
+    
+  }
+  return jresult;
+}
+
+
 #ifdef __cplusplus
 }
 #endif
index c3c6d5f..581813d 100644 (file)
@@ -52,14 +52,13 @@ public class testReadWrite {
        public void putAndGetComplexDoubleTest() throws NullPointerException, InitializationException {
         double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};
         double [][]aImg={{212.2, 221.0, 423.0, 393.0},{234.2, 244.0, 441.0, 407.0}};
-        System.out.println("ici");
+
         ScilabDouble aOriginal = new ScilabDouble(a, aImg);
-        System.out.println("ici 2"+aOriginal);
+        System.out.println("aOriginal: "+aOriginal);
         sci.put("a",aOriginal);
-        System.out.println("ici 2.0");
 
         ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");
-        System.out.println("ici 3"+aFromScilab);
+        System.out.println("aFromScilab: "+aFromScilab);
         assert aFromScilab.equals(aOriginal);
     }
 
index b48d25f..d44b67d 100644 (file)
@@ -129,6 +129,26 @@ public class ScilabDouble implements ScilabType {
                this.imaginaryPart = imaginaryPart;
        }
 
+
+       /**
+        * Get complex matrix as a serialized form
+        * 
+        * @return the serialized matrix with complex values
+        */
+       public double[] getSerializedComplexMatrix() {
+        int size = this.getHeight()*this.getWidth();
+        double [] serializedComplexMatrix = new double[size*2];
+        for (int i = 0; i < this.getHeight(); i++) {
+            for (int j = 0; j < this.getWidth(); j++) {
+                serializedComplexMatrix[j * this.getHeight() + i] = realPart[i][j];
+                serializedComplexMatrix[size+j * this.getHeight() + i] = imaginaryPart[i][j];
+            }
+        }
+
+        return serializedComplexMatrix;
+       }
+
+
        /**
         * @return the height of the data matrix
         * @see org.scilab.modules.types.scilabTypes.ScilabType#getHeight()