prepare fftw to Scilab 6 87/8487/2
Antoine ELIAS [Thu, 2 Aug 2012 10:16:21 +0000 (12:16 +0200)]
Change-Id: I24755039083d9a87e0b5d184ff17aff803bc4e6c

scilab/modules/fftw/sci_gateway/c/sci_disposefftwlibrary.c
scilab/modules/fftw/sci_gateway/c/sci_fftw.c
scilab/modules/fftw/sci_gateway/c/sci_fftw_flags.c
scilab/modules/fftw/sci_gateway/c/sci_fftw_forget_wisdom.c
scilab/modules/fftw/sci_gateway/c/sci_fftwlibraryisloaded.c
scilab/modules/fftw/sci_gateway/c/sci_get_fftw_wisdom.c
scilab/modules/fftw/sci_gateway/c/sci_loadfftwlibrary.c
scilab/modules/fftw/sci_gateway/c/sci_set_fftw_wisdom.c
scilab/modules/fftw/src/c/with_fftw.c

index 68ccbca..ae2a916 100644 (file)
@@ -1,14 +1,14 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006 - INRIA - Allan CORNET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2006 - INRIA - Allan CORNET
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 
 #include "callfftw.h"
 #include "gw_fftw.h"
 /*--------------------------------------------------------------------------*/
 int sci_disposefftwlibrary(char *fname,unsigned long fname_len)
 {
-  static int l1,n1;
+    static int l1,n1;
 
-  n1=1;
-  if ( DisposeFFTWLibrary() )
+    n1=1;
+    if ( DisposeFFTWLibrary() )
     {
-      CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
-      *istk(l1)=(int)(TRUE);
+        CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
+        *istk(l1)=(int)(TRUE);
     }
-  else
+    else
     {
-      CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
-      *istk(l1)=(int)(FALSE);
+        CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
+        *istk(l1)=(int)(FALSE);
     }
 
-  LhsVar(1)=Rhs+1;
-  PutLhsVar();
+    LhsVar(1)=Rhs+1;
+    PutLhsVar();
 
-  return(0);
+    return(0);
 }
 /*--------------------------------------------------------------------------*/
index f522735..1363383 100644 (file)
@@ -1,17 +1,17 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006/2007 - INRIA - Alan LAYEC
- * Copyright (C) 2007 - INRIA - Allan CORNET
- * Copyright (C) 2012 - DIGITEO - Allan CORNET
- * Copyright (C) 2012 - INRIA - Serge STEER
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2006/2007 - INRIA - Alan LAYEC
+* Copyright (C) 2007 - INRIA - Allan CORNET
+* Copyright (C) 2012 - DIGITEO - Allan CORNET
+* Copyright (C) 2012 - INRIA - Serge STEER
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 /*--------------------------------------------------------------------------*/
 #include "stack-c.h"
 #include "fftw_utilities.h"
@@ -39,38 +39,38 @@ static SciErr allocComplexArrayOfDouble(void* _pvCtx, int _iVar, int ndims, int
 static SciErr getScalarIntArg(void* _pvCtx, int _iVar, char *fname, int *value);
 static SciErr getVectorIntArg(void* _pvCtx, int _iVar, char *fname, int *pndims, int **pDim);
 static BOOL isHyperMatrixMlist(void* _pvCtx, int *piAddressVar);
-static int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt, guru_dim_struct gdim);
-static int sci_fft_2args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt);
-static int sci_fft_3args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt);
-static int sci_fft_4args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt);
+static int sci_fft_gen(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt, guru_dim_struct gdim);
+static int sci_fft_2args(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt);
+static int sci_fft_3args(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt);
+static int sci_fft_4args(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt);
 /*--------------------------------------------------------------------------*/
 
 int WITHMKL = 0;
 /* fftw function.
- *
- * Scilab Calling sequence :
- *   fftw(A [,option])
- *   fftw(A,sign [,option])
- *   fftw(A,sel,sign [,option])
- *   fftw(A,sign,dim,incr [,option])
- *
- * Input : A : a scilab double complex or real vector, matrix or hypermatrix
- *
- *         sign : a scilab double or integer scalar (-1 or 1): the sign
- *                  in the exponential component
- *
- *         sel : a scilab double or integer vector, the selection of dimensions
-
- *         dim : a scilab double or integer vector: the dimensions
- *                  of the Fast Fourier Transform to perform
- *
- *         incr : a scilab double or integer vector: the increments
- *                  of the Fast Fourier Transform to perform
- *
- * Output : a scilab double complex or real array with same shape as A that
- *          gives the result of the transform.
- *
- */
+*
+* Scilab Calling sequence :
+*   fftw(A [,option])
+*   fftw(A,sign [,option])
+*   fftw(A,sel,sign [,option])
+*   fftw(A,sign,dim,incr [,option])
+*
+* Input : A : a scilab double complex or real vector, matrix or hypermatrix
+*
+*         sign : a scilab double or integer scalar (-1 or 1): the sign
+*                  in the exponential component
+*
+*         sel : a scilab double or integer vector, the selection of dimensions
+
+*         dim : a scilab double or integer vector: the dimensions
+*                  of the Fast Fourier Transform to perform
+*
+*         incr : a scilab double or integer vector: the increments
+*                  of the Fast Fourier Transform to perform
+*
+* Output : a scilab double complex or real array with same shape as A that
+*          gives the result of the transform.
+*
+*/
 int sci_fftw(char *fname, unsigned long fname_len)
 {
     SciErr sciErr;
@@ -87,8 +87,8 @@ int sci_fftw(char *fname, unsigned long fname_len)
     int isn = FFTW_FORWARD;
     WITHMKL = withMKL();
     /****************************************
-     * Basic constraints on rhs arguments  *
-     ****************************************/
+    * Basic constraints on rhs arguments  *
+    ****************************************/
 
     /* check min/max lhs/rhs arguments of scilab function */
     CheckRhs(1, 5);
@@ -111,7 +111,7 @@ int sci_fftw(char *fname, unsigned long fname_len)
     }
 
     if ((iTypeOne == sci_list) ||
-            (iTypeOne == sci_tlist))
+        (iTypeOne == sci_tlist))
     {
         OverLoad(1);
         return 0;
@@ -147,7 +147,7 @@ int sci_fftw(char *fname, unsigned long fname_len)
                 else
                 {
                     Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),
-                             fname, Rhs, "\"symmetric\"", "\"nonsymmetric\"");
+                        fname, Rhs, "\"symmetric\"", "\"nonsymmetric\"");
                     freeAllocatedSingleString(option);
                     option = NULL;
                     return 0;
@@ -159,7 +159,7 @@ int sci_fftw(char *fname, unsigned long fname_len)
             else
             {
                 Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"),
-                         fname, Rhs, "\"full\", \"same\"", "\"valid\"");
+                    fname, Rhs, "\"full\", \"same\"", "\"valid\"");
                 return 0;
             }
         }
@@ -183,7 +183,7 @@ int sci_fftw(char *fname, unsigned long fname_len)
         if ((isn !=  FFTW_FORWARD) && (isn !=  FFTW_BACKWARD))
         {
             Scierror(53, _("%s: Wrong value for input argument #%d: %d or %d expected.\n"),
-                     fname, 2, FFTW_FORWARD, FFTW_BACKWARD);
+                fname, 2, FFTW_FORWARD, FFTW_BACKWARD);
             return(0);
         }
     }
@@ -193,7 +193,7 @@ int sci_fftw(char *fname, unsigned long fname_len)
     if (!getArrayOfDouble(pvApiCtx, piAddr, &ndimsA, &dimsA, &Ar, &Ai))
     {
         Scierror(999, _("%s: Wrong type for argument #%d: Array of floating point numbers expected.\n"),
-                 fname, 1);
+            fname, 1);
         return 0;
     }
 
@@ -202,17 +202,17 @@ int sci_fftw(char *fname, unsigned long fname_len)
     if (rhs < 3)
     {
         /* fftw(A ,sign [,option])*/
-        sci_fft_2args(fname, ndimsA, dimsA, Ar, Ai, isn, iopt);
+        sci_fft_2args(pvApiCtx, fname, ndimsA, dimsA, Ar, Ai, isn, iopt);
     }
     else if (rhs == 3)
     {
         /* fftw(A ,sign ,sel [,option])*/
-        sci_fft_3args(fname, ndimsA, dimsA, Ar, Ai, isn, iopt);
+        sci_fft_3args(pvApiCtx, fname, ndimsA, dimsA, Ar, Ai, isn, iopt);
     }
     else if (rhs == 4)
     {
         /* fftw(A ,sign ,dim,incr [option])*/
-        sci_fft_4args(fname, ndimsA, dimsA, Ar, Ai, isn, iopt);
+        sci_fft_4args(pvApiCtx, fname, ndimsA, dimsA, Ar, Ai, isn, iopt);
     }
 
     return 0;
@@ -406,32 +406,32 @@ SciErr getScalarIntArg(void* _pvCtx, int _iVar, char *fname, int *value)
 
         switch (iPrec)
         {
-            case SCI_INT8 :
+        case SCI_INT8 :
             {
                 getScalarInteger8(_pvCtx, piAddr, &t_c);
                 *value = (int)t_c;
             }
-            case SCI_INT16 :
+        case SCI_INT16 :
             {
                 getScalarInteger16(_pvCtx, piAddr, &t_s);
                 *value = (int)t_s;
             }
-            case SCI_INT32 :
+        case SCI_INT32 :
             {
                 getScalarInteger32(_pvCtx, piAddr, &t_i);
                 *value = (int)t_i;
             }
-            case SCI_UINT8 :
+        case SCI_UINT8 :
             {
                 getScalarUnsignedInteger8(_pvCtx, piAddr, &t_uc);
                 *value = (int)t_uc;
             }
-            case SCI_UINT16 :
+        case SCI_UINT16 :
             {
                 getScalarUnsignedInteger16(_pvCtx, piAddr, &t_us);
                 *value = (int)t_us;
             }
-            case SCI_UINT32 :
+        case SCI_UINT32 :
             {
                 getScalarUnsignedInteger32(_pvCtx, piAddr, &t_ui);
                 *value = (int)t_ui;
@@ -441,8 +441,8 @@ SciErr getScalarIntArg(void* _pvCtx, int _iVar, char *fname, int *value)
     else
     {
         addErrorMessage(&sciErr, API_ERROR_GET_INT,
-                        _("%s: Wrong type for argument #%d: An integer or a floating point number expected.\n"),
-                        fname, _iVar);
+            _("%s: Wrong type for argument #%d: An integer or a floating point number expected.\n"),
+            fname, _iVar);
         return sciErr;
     }
     return sciErr;
@@ -489,13 +489,13 @@ SciErr getVectorIntArg(void* _pvCtx, int _iVar, char *fname, int *pndims, int **
     if (ndims <= 0)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_INT,
-                        _("%s: Wrong size for input argument #%d.\n"), fname, _iVar);
+            _("%s: Wrong size for input argument #%d.\n"), fname, _iVar);
         return sciErr;
     }
     if ((Dim = (int *)MALLOC(ndims * sizeof(int))) == NULL)
     {
         addErrorMessage(&sciErr, API_ERROR_GET_INT,
-                        _("%s: Cannot allocate more memory.\n"), fname);
+            _("%s: Cannot allocate more memory.\n"), fname);
         return sciErr;
     }
     *pDim = Dim;
@@ -509,30 +509,30 @@ SciErr getVectorIntArg(void* _pvCtx, int _iVar, char *fname, int *pndims, int **
         getMatrixOfIntegerPrecision(_pvCtx, piAddr, &iPrec);
         switch (iPrec)
         {
-            case SCI_INT8 :
-                getMatrixOfInteger8(_pvCtx, piAddr, &mDim, &nDim, &p_c);
-                for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_c[i]);
-                break;
-            case SCI_INT16 :
-                getMatrixOfInteger16(_pvCtx, piAddr, &mDim, &nDim, &p_s);
-                for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_s[i]);
-                break;
-            case SCI_INT32 :
-                getMatrixOfInteger32(_pvCtx, piAddr, &mDim, &nDim, &p_i);
-                for (i = 0; i < ndims; i++)  Dim[i]  = (int)(p_i[i]);
-                break;
-            case SCI_UINT8 :
-                getMatrixOfUnsignedInteger8(_pvCtx, piAddr, &mDim, &nDim, &p_uc);
-                for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_uc[i]);
-                break;
-            case SCI_UINT16 :
-                getMatrixOfUnsignedInteger16(_pvCtx, piAddr, &mDim, &nDim, &p_us);
-                for (i = 0; i < ndims; i++) Dim[i]  = (int) p_us[i];
-                break;
-            case SCI_UINT32 :
-                getMatrixOfUnsignedInteger32(_pvCtx, piAddr, &mDim, &nDim, &p_ui);
-                for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_ui[i]);
-                break;
+        case SCI_INT8 :
+            getMatrixOfInteger8(_pvCtx, piAddr, &mDim, &nDim, &p_c);
+            for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_c[i]);
+            break;
+        case SCI_INT16 :
+            getMatrixOfInteger16(_pvCtx, piAddr, &mDim, &nDim, &p_s);
+            for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_s[i]);
+            break;
+        case SCI_INT32 :
+            getMatrixOfInteger32(_pvCtx, piAddr, &mDim, &nDim, &p_i);
+            for (i = 0; i < ndims; i++)  Dim[i]  = (int)(p_i[i]);
+            break;
+        case SCI_UINT8 :
+            getMatrixOfUnsignedInteger8(_pvCtx, piAddr, &mDim, &nDim, &p_uc);
+            for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_uc[i]);
+            break;
+        case SCI_UINT16 :
+            getMatrixOfUnsignedInteger16(_pvCtx, piAddr, &mDim, &nDim, &p_us);
+            for (i = 0; i < ndims; i++) Dim[i]  = (int) p_us[i];
+            break;
+        case SCI_UINT32 :
+            getMatrixOfUnsignedInteger32(_pvCtx, piAddr, &mDim, &nDim, &p_ui);
+            for (i = 0; i < ndims; i++) Dim[i]  = (int)(p_ui[i]);
+            break;
         }
     }
     else
@@ -540,13 +540,13 @@ SciErr getVectorIntArg(void* _pvCtx, int _iVar, char *fname, int *pndims, int **
         FREE(Dim);
         Dim = NULL;
         addErrorMessage(&sciErr, API_ERROR_GET_INT,
-                        _("%s: Wrong type for argument #%d: An array of floating point or integer numbers expected.\n"), fname, _iVar);
+            _("%s: Wrong type for argument #%d: An array of floating point or integer numbers expected.\n"), fname, _iVar);
         return sciErr;
     }
     return sciErr;
 }
 
-int sci_fft_2args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt)
+int sci_fft_2args(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt)
 {
     /*FFTW specific library variable */
     guru_dim_struct gdim = {0, NULL, 0, NULL};
@@ -572,8 +572,8 @@ int sci_fft_2args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai,
     /* void or scalar input gives void output or scalar*/
     if (ndims == 0 )
     {
-        LhsVar(1) =  1;
-        PutLhsVar();
+        *assignOutputVariable(_pvCtx, 1) =  1;
+        returnArguments(_pvCtx);
         return(0);
     }
 
@@ -601,14 +601,14 @@ int sci_fft_2args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai,
     gdim.howmany_dims = NULL;
 
 
-    if (!sci_fft_gen(fname, ndimsA, dimsA,  Ar,  Ai, isn, iopt, gdim))  goto ERR;
+    if (!sci_fft_gen(_pvCtx, fname, ndimsA, dimsA,  Ar,  Ai, isn, iopt, gdim))  goto ERR;
 
 
     /***********************************
-     * Return results in lhs argument *
-     ***********************************/
+    * Return results in lhs argument *
+    ***********************************/
 
-    PutLhsVar();
+    returnArguments(_pvCtx);
 ERR:
     FREE(gdim.dims);
     FREE(gdim.howmany_dims);
@@ -616,7 +616,7 @@ ERR:
 }
 
 
-int  sci_fft_3args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt)
+int  sci_fft_3args(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt)
 {
     /* API variables */
     SciErr sciErr;
@@ -650,8 +650,8 @@ int  sci_fft_3args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai,
     /* void or scalar input gives void output or scalar*/
     if (ndims == 0 )
     {
-        LhsVar(1) =  1;
-        PutLhsVar();
+        *assignOutputVariable(_pvCtx, 1) =  1;
+        returnArguments(_pvCtx);
         return(0);
     }
 
@@ -783,19 +783,19 @@ int  sci_fft_3args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai,
         }
     }
 
-    if (!sci_fft_gen(fname, ndimsA, dimsA, Ar,  Ai, isn, iopt, gdim))  goto ERR;
+    if (!sci_fft_gen(_pvCtx, fname, ndimsA, dimsA, Ar,  Ai, isn, iopt, gdim))  goto ERR;
     /***********************************
-     * Return results in lhs argument *
-     ***********************************/
+    * Return results in lhs argument *
+    ***********************************/
 
-    PutLhsVar();
+    returnArguments(_pvCtx);
 ERR:
     FREE(gdim.dims);
     FREE(gdim.howmany_dims);
     return(0);
 }
 
-int sci_fft_4args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt)
+int sci_fft_4args(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt)
 {
     /* API variables */
     SciErr sciErr;
@@ -827,8 +827,8 @@ int sci_fft_4args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai,
     /* void or scalar input gives void output or scalar*/
     if (lA <= 1 )
     {
-        LhsVar(1) =  1;
-        PutLhsVar();
+        *assignOutputVariable(_pvCtx, 1) =  1;
+        returnArguments(_pvCtx);
         return(0);
     }
 
@@ -1041,13 +1041,13 @@ int sci_fft_4args(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai,
             ih++;
         }
     }
-    if (!sci_fft_gen(fname, ndimsA, dimsA, Ar,  Ai, isn, iopt, gdim))  goto ERR;
+    if (!sci_fft_gen(_pvCtx, fname, ndimsA, dimsA, Ar,  Ai, isn, iopt, gdim))  goto ERR;
 
     /***********************************
-     * Return results in lhs argument *
-     ***********************************/
+    * Return results in lhs argument *
+    ***********************************/
 
-    PutLhsVar();
+    returnArguments(_pvCtx);
 ERR:
     FREE(Dim1);
     FREE(Incr);
@@ -1118,7 +1118,7 @@ BOOL isHyperMatrixMlist(void* _pvCtx, int *piAddressVar)
     return FALSE;
 }
 /*--------------------------------------------------------------------------*/
-int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt, guru_dim_struct gdim)
+int sci_fft_gen(void* _pvCtx, char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, int isn, int iopt, guru_dim_struct gdim)
 {
     /* API variables */
     SciErr sciErr;
@@ -1167,7 +1167,8 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
     {
         issymA = 0;
     }
-    LhsVar(1) = 1; /* assume inplace transform*/
+
+    *assignOutputVariable(_pvCtx, 1) =  1;/* assume inplace transform*/
 
     if (WITHMKL)
     {
@@ -1178,7 +1179,7 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
             if (issymA)
             {
                 /* result will be real, the imaginary part of A can be allocated alone */
-                sciErr = allocMatrixOfDouble(pvApiCtx, Rhs + 1, 1, lA, &Ai);
+                sciErr = allocMatrixOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, 1, lA, &Ai);
                 if (sciErr.iErr)
                 {
                     Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
@@ -1189,7 +1190,7 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
             else
             {
                 /* result will be complex, realloc A for inplace computation */
-                sciErr = allocComplexArrayOfDouble(pvApiCtx, Rhs + 1, ndimsA, dimsA, &ri, &Ai);
+                sciErr = allocComplexArrayOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, ndimsA, dimsA, &ri, &Ai);
                 if (sciErr.iErr)
                 {
                     Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
@@ -1198,7 +1199,7 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
                 C2F(dcopy)(&lA, Ar, &one, ri, &one);
                 Ar = ri;
                 C2F(dset)(&lA, &dzero, Ai, &one);
-                LhsVar(1) = Rhs + 1;
+                *assignOutputVariable(_pvCtx, 1) =  *getNbInputArgument(_pvCtx) + 1;
                 isrealA = 0;
             }
         }
@@ -1207,7 +1208,7 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
     if (!isrealA && issymA) /* A is complex but result is real */
     {
         /* result will be complex, realloc real part of A for real part inplace computation */
-        sciErr = allocArrayOfDouble(pvApiCtx, Rhs + 1, ndimsA, dimsA, &ri);
+        sciErr = allocArrayOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, ndimsA, dimsA, &ri);
         if (sciErr.iErr)
         {
             Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
@@ -1215,7 +1216,7 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
         }
         C2F(dcopy)(&lA, Ar, &one, ri, &one);
         Ar = ri;
-        LhsVar(1) = Rhs + 1;
+        *assignOutputVariable(pvApiCtx, 1) = *getNbInputArgument(_pvCtx) + 1;
     }
 
     /* Set pointers on real and imaginary part of the input */
@@ -1231,8 +1232,8 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
         {
             /*r2r =  isrealA &&  issymA*/
             /* there is no general plan able to compute r2r transform so it is tranformed into
-               a R2c plan. The computed imaginary part will be zero*/
-            sciErr = allocMatrixOfDouble(pvApiCtx, Rhs + 1, 1, lA,  &io);
+            a R2c plan. The computed imaginary part will be zero*/
+            sciErr = allocMatrixOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, 1, lA,  &io);
             if (sciErr.iErr)
             {
                 Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
@@ -1245,13 +1246,13 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
         {
             /*r2c =  isrealA && ~issymA;*/
             /* transform cannot be done in place */
-            sciErr = allocComplexArrayOfDouble(pvApiCtx, Rhs + 1, ndimsA, dimsA, &ro, &io);
+            sciErr = allocComplexArrayOfDouble(pvApiCtx, *getNbInputArgument(_pvCtx) + 1, ndimsA, dimsA, &ro, &io);
             if (sciErr.iErr)
             {
                 Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
                 goto ERR;
             }
-            LhsVar(1) = Rhs + 1;
+            *assignOutputVariable(pvApiCtx, 1) = *getNbInputArgument(_pvCtx) + 1;
             type = R2C_PLAN; /* fftw_plan_guru_split_dft_r2c plans for an FFTW_FORWARD transform*/
             if (isn == FFTW_BACKWARD)
             {
@@ -1323,61 +1324,61 @@ int sci_fft_gen(char *fname, int ndimsA, int *dimsA, double *Ar,  double *Ai, in
     /* Post treatment */
     switch (type)
     {
-        case R2R_PLAN:
+    case R2R_PLAN:
+        if (complete_array(ro, NULL, gdim) == -1)
+        {
+            Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
+            goto ERR;
+        }
+        break;
+    case C2R_PLAN:
+        break;
+    case R2C_PLAN:
+        if (issymA)
+        {
+            /*R2C has been used to solve an r2r problem*/
             if (complete_array(ro, NULL, gdim) == -1)
             {
                 Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
                 goto ERR;
             }
-            break;
-        case C2R_PLAN:
-            break;
-        case R2C_PLAN:
-            if (issymA)
+        }
+        else
+        {
+            if (complete_array(ro, io, gdim) == -1)
             {
-                /*R2C has been used to solve an r2r problem*/
-                if (complete_array(ro, NULL, gdim) == -1)
-                {
-                    Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
-                    goto ERR;
-                }
+                Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
+                goto ERR;
             }
-            else
+            if (isn == FFTW_BACKWARD)
+            {
+                /*conjugate result */
+                double ak = -1.0;
+                C2F(dscal)(&lA, &ak, io, &one);
+            }
+        }
+        break;
+    case C2C_PLAN:
+        if (WITHMKL && isrealA_save)
+        {
+            if (isn == FFTW_FORWARD)
             {
                 if (complete_array(ro, io, gdim) == -1)
                 {
                     Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
                     goto ERR;
                 }
-                if (isn == FFTW_BACKWARD)
-                {
-                    /*conjugate result */
-                    double ak = -1.0;
-                    C2F(dscal)(&lA, &ak, io, &one);
-                }
             }
-            break;
-        case C2C_PLAN:
-            if (WITHMKL && isrealA_save)
+            else
             {
-                if (isn == FFTW_FORWARD)
-                {
-                    if (complete_array(ro, io, gdim) == -1)
-                    {
-                        Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
-                        goto ERR;
-                    }
-                }
-                else
+                if (complete_array(io, ro, gdim) == -1)
                 {
-                    if (complete_array(io, ro, gdim) == -1)
-                    {
-                        Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
-                        goto ERR;
-                    }
+                    Scierror(999, _("%s: Cannot allocate more memory.\n"), fname);
+                    goto ERR;
                 }
             }
-            break;
+        }
+        break;
     }
 
     return(1);
index f5f785f..08d6569 100644 (file)
@@ -1,16 +1,16 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006/2007 - INRIA - Alan LAYEC
- * Copyright (C) 2007 - INRIA - Allan CORNET
- * Copyright (C) 2012 - DIGITEO - Allan CORNET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2006/2007 - INRIA - Alan LAYEC
+* Copyright (C) 2007 - INRIA - Allan CORNET
+* Copyright (C) 2012 - DIGITEO - Allan CORNET
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 /*--------------------------------------------------------------------------*/
 #include <string.h>
 #include "fftw_utilities.h"
 #endif
 /*--------------------------------------------------------------------------*/
 /* fftw_flags function.
- *
- * Scilab Calling sequence :
- *   -->[a,b]=fftw_flags();
- * or
- *   -->[a,b]=fftw_flags(S);
- *
- *  a is an int scalar. (the int value of
- *                            the flag parameter of fftw)
- *  b is a string matrix.(the string values of
- *                             the flag parameter of fftw)
- *  S is a string matrix or an int or a double scalar
- *  given the value(s) of the fftw flag parameter.
- *
- *  This function gives and set the flag parameter of fftw
- *  when creating a new plan.
- *  This should be done before calling fftw function.
- *  (default is FFTW_ESTIMATE)
- */
+*
+* Scilab Calling sequence :
+*   -->[a,b]=fftw_flags();
+* or
+*   -->[a,b]=fftw_flags(S);
+*
+*  a is an int scalar. (the int value of
+*                            the flag parameter of fftw)
+*  b is a string matrix.(the string values of
+*                             the flag parameter of fftw)
+*  S is a string matrix or an int or a double scalar
+*  given the value(s) of the fftw flag parameter.
+*
+*  This function gives and set the flag parameter of fftw
+*  when creating a new plan.
+*  This should be done before calling fftw function.
+*  (default is FFTW_ESTIMATE)
+*/
 /*--------------------------------------------------------------------------*/
 int sci_fftw_flags(char *fname, unsigned long fname_len)
 {
-  /* declaration of variables to store scilab parameters address */
-  static int l1 = 0, m1 = 0, n1 = 0;
-  SciIntMat M1;
-  char **Str1 = NULL;
+    /* declaration of variables to store scilab parameters address */
+    static int l1 = 0, m1 = 0, n1 = 0;
+    SciIntMat M1;
+    char **Str1 = NULL;
 
-  static int l2 = 0, m2 = 0, n2 = 0;
+    static int l2 = 0, m2 = 0, n2 = 0;
 
-  char **Str3 = NULL;
+    char **Str3 = NULL;
 
-  /* please update me ! */
-  static int nb_flag = 22;
-  static char *Str[] =
+    /* please update me ! */
+    static int nb_flag = 22;
+    static char *Str[] =
     {
-      /* documented flags */
-      "FFTW_MEASURE",
-      "FFTW_DESTROY_INPUT",
-      "FFTW_UNALIGNED",
-      "FFTW_CONSERVE_MEMORY",
-      "FFTW_EXHAUSTIVE",
-      "FFTW_PRESERVE_INPUT",
-      "FFTW_PATIENT",
-      "FFTW_ESTIMATE",
-
-      /* undocumented beyond-guru flags */
-      "FFTW_ESTIMATE_PATIENT",
-      "FFTW_BELIEVE_PCOST",
-      "FFTW_NO_DFT_R2HC",
-      "FFTW_NO_NONTHREADED",
-      "FFTW_NO_BUFFERING",
-      "FFTW_NO_INDIRECT_OP",
-      "FFTW_ALLOW_LARGE_GENERIC",
-      "FFTW_NO_RANK_SPLITS",
-      "FFTW_NO_VRANK_SPLITS",
-      "FFTW_NO_VRECURSE",
-      "FFTW_NO_SIMD",
-      "FFTW_NO_SLOW",
-      "FFTW_NO_FIXED_RADIX_LARGE_N",
-      "FFTW_ALLOW_PRUNING"
+        /* documented flags */
+        "FFTW_MEASURE",
+        "FFTW_DESTROY_INPUT",
+        "FFTW_UNALIGNED",
+        "FFTW_CONSERVE_MEMORY",
+        "FFTW_EXHAUSTIVE",
+        "FFTW_PRESERVE_INPUT",
+        "FFTW_PATIENT",
+        "FFTW_ESTIMATE",
+
+        /* undocumented beyond-guru flags */
+        "FFTW_ESTIMATE_PATIENT",
+        "FFTW_BELIEVE_PCOST",
+        "FFTW_NO_DFT_R2HC",
+        "FFTW_NO_NONTHREADED",
+        "FFTW_NO_BUFFERING",
+        "FFTW_NO_INDIRECT_OP",
+        "FFTW_ALLOW_LARGE_GENERIC",
+        "FFTW_NO_RANK_SPLITS",
+        "FFTW_NO_VRANK_SPLITS",
+        "FFTW_NO_VRECURSE",
+        "FFTW_NO_SIMD",
+        "FFTW_NO_SLOW",
+        "FFTW_NO_FIXED_RADIX_LARGE_N",
+        "FFTW_ALLOW_PRUNING"
     };
 
-  static unsigned flagt[] =
+    static unsigned flagt[] =
     {
-      /* documented flags */
-      FFTW_MEASURE,
-      FFTW_DESTROY_INPUT,
-      FFTW_UNALIGNED,
-      FFTW_CONSERVE_MEMORY,
-      FFTW_EXHAUSTIVE,
-      FFTW_PRESERVE_INPUT,
-      FFTW_PATIENT,
-      FFTW_ESTIMATE,
-
-      /* undocumented beyond-guru flags */
-      FFTW_ESTIMATE_PATIENT,
-      FFTW_BELIEVE_PCOST,
-      FFTW_NO_DFT_R2HC,
-      FFTW_NO_NONTHREADED,
-      FFTW_NO_BUFFERING,
-      FFTW_NO_INDIRECT_OP,
-      FFTW_ALLOW_LARGE_GENERIC,
-      FFTW_NO_RANK_SPLITS,
-      FFTW_NO_VRANK_SPLITS,
-      FFTW_NO_VRECURSE,
-      FFTW_NO_SIMD,
-      FFTW_NO_SLOW,
-      FFTW_NO_FIXED_RADIX_LARGE_N,
-      FFTW_ALLOW_PRUNING
+        /* documented flags */
+        FFTW_MEASURE,
+        FFTW_DESTROY_INPUT,
+        FFTW_UNALIGNED,
+        FFTW_CONSERVE_MEMORY,
+        FFTW_EXHAUSTIVE,
+        FFTW_PRESERVE_INPUT,
+        FFTW_PATIENT,
+        FFTW_ESTIMATE,
+
+        /* undocumented beyond-guru flags */
+        FFTW_ESTIMATE_PATIENT,
+        FFTW_BELIEVE_PCOST,
+        FFTW_NO_DFT_R2HC,
+        FFTW_NO_NONTHREADED,
+        FFTW_NO_BUFFERING,
+        FFTW_NO_INDIRECT_OP,
+        FFTW_ALLOW_LARGE_GENERIC,
+        FFTW_NO_RANK_SPLITS,
+        FFTW_NO_VRANK_SPLITS,
+        FFTW_NO_VRECURSE,
+        FFTW_NO_SIMD,
+        FFTW_NO_SLOW,
+        FFTW_NO_FIXED_RADIX_LARGE_N,
+        FFTW_ALLOW_PRUNING
     };
 
-  unsigned flagv = 0;
+    unsigned flagv = 0;
 
-  int i = 0, j = 0;
+    int i = 0, j = 0;
 
-  CheckRhs(0, 1);
+    CheckRhs(0, 1);
 
-  if (Rhs == 0)
+    if (Rhs == 0)
     {
-      // nothing
+        // nothing
     }
-  else
+    else
     {
-      switch(VarType(1))
+        switch(VarType(1))
         {
         case sci_ints:
 
-          /* int */
-          GetRhsVar(1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m1, &n1, &M1);
-          CheckDims(1, m1, n1, 1, 1);
-          setCurrentFftwFlags(((int *)M1.D)[0]);
-          break;
+            /* int */
+            GetRhsVar(1, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m1, &n1, &M1);
+            CheckDims(1, m1, n1, 1, 1);
+            setCurrentFftwFlags(((int *)M1.D)[0]);
+            break;
         case sci_matrix:
-          /* double */
-          GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-          CheckDims(1, m1, n1, 1, 1);
-          setCurrentFftwFlags((int)*stk(l1));
-          break;
+            /* double */
+            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
+            CheckDims(1, m1, n1, 1, 1);
+            setCurrentFftwFlags((int)*stk(l1));
+            break;
         case sci_strings:
-          /* string */
-          GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &Str1);
-          for (j = 0; j < m1 * n1; j++)
+            /* string */
+            GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &Str1);
+            for (j = 0; j < m1 * n1; j++)
             {
-              for (i = 0; i < nb_flag; i++)
+                for (i = 0; i < nb_flag; i++)
                 {
-                  if (strcmp(Str1[j], Str[i]) == 0) break;
+                    if (strcmp(Str1[j], Str[i]) == 0) break;
                 }
 
-              if (i == nb_flag)
+                if (i == nb_flag)
                 {
-                  freeArrayOfString(Str1, m1 * n1);
-                  Scierror(999, _("%s: Wrong values for input argument #%d: FFTW flag expected.\n"), fname, 1);
-                  return 0;
+                    freeArrayOfString(Str1, m1 * n1);
+                    Scierror(999, _("%s: Wrong values for input argument #%d: FFTW flag expected.\n"), fname, 1);
+                    return 0;
                 }
-              else
+                else
                 {
-                  if (i > 0)
+                    if (i > 0)
                     {
-                      flagv = ( flagv | (1U << (i - 1)) );
+                        flagv = ( flagv | (1U << (i - 1)) );
                     }
                 }
             }
-          setCurrentFftwFlags(flagv);
-          freeArrayOfString(Str1, m1 * n1);
-          break;
+            setCurrentFftwFlags(flagv);
+            freeArrayOfString(Str1, m1 * n1);
+            break;
 
         default:
-          Scierror(53, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
-          return 0;
+            Scierror(53, _("%s: Wrong type for input argument #%d.\n"), fname, 1);
+            return 0;
         }
     }
 
-  /* return value of Sci_Plan.flags in position 2 */
-  m2 = 1;
-  n2 = m2;
-  l2 = I_INT32;
-  CreateVar(Rhs + 2, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m2, &n2, &l2);
-  *istk(l2) = (int) getCurrentFftwFlags();
+    /* return value of Sci_Plan.flags in position 2 */
+    m2 = 1;
+    n2 = m2;
+    l2 = I_INT32;
+    CreateVar(Rhs + 2, MATRIX_OF_VARIABLE_SIZE_INTEGER_DATATYPE, &m2, &n2, &l2);
+    *istk(l2) = (int) getCurrentFftwFlags();
 
-  /*Test for only FFTW_MEASURE*/
-  if (getCurrentFftwFlags() == 0)
+    /*Test for only FFTW_MEASURE*/
+    if (getCurrentFftwFlags() == 0)
     {
-      j = 1;
-      if ((Str3 = (char **)MALLOC(sizeof(char *))) == NULL)
+        j = 1;
+        if ((Str3 = (char **)MALLOC(sizeof(char *))) == NULL)
         {
-          Scierror(999, _("%s: No more memory.\n"), fname);
-          return 0;
+            Scierror(999, _("%s: No more memory.\n"), fname);
+            return 0;
         }
 
-      Str3[0] = strdup(Str[0]);
-      if (Str3[0] == NULL)
+        Str3[0] = strdup(Str[0]);
+        if (Str3[0] == NULL)
         {
-          Scierror(999, _("%s: No more memory.\n"), fname);
-          return 0;
+            Scierror(999, _("%s: No more memory.\n"), fname);
+            return 0;
         }
     }
-  else
+    else
     {
-      j = 0;
-      for (i = 1;i < nb_flag; i++)
+        j = 0;
+        for (i = 1;i < nb_flag; i++)
         {
-          if((getCurrentFftwFlags() & flagt[i]) == flagt[i])
+            if((getCurrentFftwFlags() & flagt[i]) == flagt[i])
             {
-              j++;
-              if (Str3)
+                j++;
+                if (Str3)
                 {
-                  Str3 = (char **)REALLOC(Str3,sizeof(char *) * j);
+                    Str3 = (char **)REALLOC(Str3,sizeof(char *) * j);
                 }
-              else
+                else
                 {
-                  Str3 = (char **)MALLOC(sizeof(char *) * j);
+                    Str3 = (char **)MALLOC(sizeof(char *) * j);
                 }
 
-              if ( Str3 == NULL)
+                if ( Str3 == NULL)
                 {
-                  Scierror(999, _("%s: No more memory.\n"), fname);
-                  return 0;
+                    Scierror(999, _("%s: No more memory.\n"), fname);
+                    return 0;
                 }
 
-              Str3[j - 1] = strdup(Str[i]);
-              if (Str3[j - 1] == NULL)
+                Str3[j - 1] = strdup(Str[i]);
+                if (Str3[j - 1] == NULL)
                 {
-                  freeArrayOfString(Str3, j);
-                  Scierror(999, _("%s: No more memory.\n"), fname);
-                  return 0;
+                    freeArrayOfString(Str3, j);
+                    Scierror(999, _("%s: No more memory.\n"), fname);
+                    return 0;
                 }
             }
         }
     }
 
-  n1 = 1;
-  CreateVarFromPtr(Rhs + 3, MATRIX_OF_STRING_DATATYPE, &j, &n1, Str3);
-  freeArrayOfString(Str3, j);
+    n1 = 1;
+    CreateVarFromPtr(Rhs + 3, MATRIX_OF_STRING_DATATYPE, &j, &n1, Str3);
+    freeArrayOfString(Str3, j);
 
-  LhsVar(1) = Rhs + 2;
-  LhsVar(2) = Rhs + 3;
-  PutLhsVar();
-  return 0;
+    LhsVar(1) = Rhs + 2;
+    LhsVar(2) = Rhs + 3;
+    PutLhsVar();
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 870db04..459fff4 100644 (file)
@@ -1,15 +1,15 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2007 - INRIA - Alan LAYEC
- * Copyright (C) 2007 - INRIA - Allan CORNET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2007 - INRIA - Alan LAYEC
+* Copyright (C) 2007 - INRIA - Allan CORNET
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 
 #include "stack-c.h"
 #include "fftw_utilities.h"
 #include "gw_fftw.h"
 /*--------------------------------------------------------------------------*/
 /* Reset fftw wisdom
- *
- * Scilab Calling sequence :
- *   -->fftw_forget_wisdom();
- *
- * Input : Nothing
- *
- * Output : Nothing
- *
- */
+*
+* Scilab Calling sequence :
+*   -->fftw_forget_wisdom();
+*
+* Input : Nothing
+*
+* Output : Nothing
+*
+*/
 /*--------------------------------------------------------------------------*/
 int sci_fftw_forget_wisdom(char *fname,unsigned long fname_len)
 {
-  CheckRhs(0,0);
+    CheckRhs(0,0);
 
-  FreeFFTWPlan(getSci_Backward_Plan());
-  FreeFFTWPlan(getSci_Forward_Plan());
+    FreeFFTWPlan(getSci_Backward_Plan());
+    FreeFFTWPlan(getSci_Forward_Plan());
 
-  call_fftw_forget_wisdom();
+    call_fftw_forget_wisdom();
 
-  PutLhsVar();
+    PutLhsVar();
 
-  return(0);
+    return(0);
 }
 /*--------------------------------------------------------------------------*/
index cf5ac83..80b7831 100644 (file)
@@ -1,37 +1,37 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006 - INRIA - Allan CORNET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2006 - INRIA - Allan CORNET
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 #include "callfftw.h"
 #include "gw_fftw.h"
 #include "stack-c.h"
 /*--------------------------------------------------------------------------*/
 int sci_fftwlibraryisloaded(char *fname,unsigned long fname_len)
 {
-  static int l1,n1;
+    static int l1,n1;
 
-  n1=1;
-  if ( IsLoadedFFTW() )
+    n1=1;
+    if ( IsLoadedFFTW() )
     {
-      CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
-      *istk(l1)=(int)(TRUE);
+        CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
+        *istk(l1)=(int)(TRUE);
     }
-  else
+    else
     {
-      CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
-      *istk(l1)=(int)(FALSE);
+        CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
+        *istk(l1)=(int)(FALSE);
     }
 
-  LhsVar(1)=Rhs+1;
-  PutLhsVar();
+    LhsVar(1)=Rhs+1;
+    PutLhsVar();
 
-  return(0);
+    return(0);
 }
 /*--------------------------------------------------------------------------*/
index 708f51a..6023b69 100644 (file)
@@ -1,15 +1,15 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006 - INRIA - Alan LAYEC
- * Copyright (C) 2007 - INRIA - Allan CORNET
- * 
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at    
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2006 - INRIA - Alan LAYEC
+* Copyright (C) 2007 - INRIA - Allan CORNET
+* 
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at    
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 /*--------------------------------------------------------------------------*/
 #include "callfftw.h"
 #include "stack-c.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 /* Return text of fftw wisdom
- *
- * Scilab Calling sequence :
- *   -->tt=get_fftw_wisdom();
- *
- * Input : Nothing
- *
- * Output : a scilab string matrix
- *
- */
+*
+* Scilab Calling sequence :
+*   -->tt=get_fftw_wisdom();
+*
+* Input : Nothing
+*
+* Output : a scilab string matrix
+*
+*/
 int sci_get_fftw_wisdom(char *fname,unsigned long fname_len)
 {
-  int n1 = 0,i = 0,j = 0;
-  char *Str = NULL;
-  char **Str1 = NULL;
+    int n1 = 0,i = 0,j = 0;
+    char *Str = NULL;
+    char **Str1 = NULL;
 
-  CheckRhs(0,0);
-  CheckLhs(0,1);
+    CheckRhs(0,0);
+    CheckLhs(0,1);
 
-  if ((Str = call_fftw_export_wisdom_to_string())==NULL) {
-    Scierror(999,_("%s: MKL fftw library does not implement wisdom functions yet.\n"), fname);
-    return 0;
-  };
+    if ((Str = call_fftw_export_wisdom_to_string())==NULL) {
+        Scierror(999,_("%s: MKL fftw library does not implement wisdom functions yet.\n"), fname);
+        return 0;
+    };
 
-  n1 = 0; j = 0;
-  if (Str)
+    n1 = 0; j = 0;
+    if (Str)
     {
-      for(i = 0; i < (int)strlen(Str); i++)
+        for(i = 0; i < (int)strlen(Str); i++)
         {
-          if (Str[i] == '\n')
+            if (Str[i] == '\n')
             {
-              int len = 0;
-              int k = 0;
+                int len = 0;
+                int k = 0;
 
-              n1++;
+                n1++;
 
-              if (Str1)
+                if (Str1)
                 {
-                  Str1 = (char **)REALLOC(Str1,sizeof(char *)*n1);
+                    Str1 = (char **)REALLOC(Str1,sizeof(char *)*n1);
                 }
-              else
+                else
                 {
-                  Str1 = (char **)MALLOC(sizeof(char *)*n1);
+                    Str1 = (char **)MALLOC(sizeof(char *)*n1);
                 }
 
-              if (Str1 == NULL)
+                if (Str1 == NULL)
                 {
-                  Scierror(999,_("%s: No more memory.\n"), fname);
-                  if (Str)
+                    Scierror(999,_("%s: No more memory.\n"), fname);
+                    if (Str)
                     {
-                      FREE(Str);
-                      Str = NULL;
+                        FREE(Str);
+                        Str = NULL;
                     }
-                  return(0);
+                    return(0);
                 }
 
-              len = i - j;
+                len = i - j;
 
-              if ((Str1[n1 - 1] = (char *)MALLOC(sizeof(char)*(len+1))) == NULL)
+                if ((Str1[n1 - 1] = (char *)MALLOC(sizeof(char)*(len+1))) == NULL)
                 {
-                  freeArrayOfString(Str1, n1 - 1);
-                  if (Str)
+                    freeArrayOfString(Str1, n1 - 1);
+                    if (Str)
                     {
-                      FREE(Str);
-                      Str = NULL;
+                        FREE(Str);
+                        Str = NULL;
                     }
-                  Scierror(999,_("%s: No more memory.\n"),fname);
-                  return(0);
+                    Scierror(999,_("%s: No more memory.\n"),fname);
+                    return(0);
                 }
 
-              for(k = 0; k < len;k++)
+                for(k = 0; k < len;k++)
                 {
-                  Str1[n1 - 1][k] = Str[k + j];
+                    Str1[n1 - 1][k] = Str[k + j];
                 }
-              Str1[n1 - 1][len] = '\0';
-              j = i + 1;
+                Str1[n1 - 1][len] = '\0';
+                j = i + 1;
             }
         }
     }
 
-  n1++;
+    n1++;
 
-  if (Str1)
+    if (Str1)
     {
-      Str1 = (char **)REALLOC(Str1,sizeof(char *)*n1);
+        Str1 = (char **)REALLOC(Str1,sizeof(char *)*n1);
     }
-  else
+    else
     {
-      Str1 = (char **)MALLOC(sizeof(char *)*n1);
+        Str1 = (char **)MALLOC(sizeof(char *)*n1);
     }
 
-  if (Str1 == NULL)
+    if (Str1 == NULL)
     {
-      Scierror(999,_("%s: No more memory.\n"),fname);
-      if (Str)
+        Scierror(999,_("%s: No more memory.\n"),fname);
+        if (Str)
         {
-          FREE(Str);
-          Str = NULL;
+            FREE(Str);
+            Str = NULL;
         }
-      return(0);
+        return(0);
     }
 
-  if ((Str1[n1-1] = (char *)MALLOC(sizeof(char))) == NULL)
+    if ((Str1[n1-1] = (char *)MALLOC(sizeof(char))) == NULL)
     {
-      freeArrayOfString(Str1, n1 - 1);
-      if (Str)
+        freeArrayOfString(Str1, n1 - 1);
+        if (Str)
         {
-          FREE(Str);
-          Str = NULL;
+            FREE(Str);
+            Str = NULL;
         }
-      Scierror(999, _("%s: No more memory.\n"), fname);
-      return(0);
+        Scierror(999, _("%s: No more memory.\n"), fname);
+        return(0);
     }
-  Str1[n1 - 1][0] = '\0';
+    Str1[n1 - 1][0] = '\0';
 
-  CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &n1, (j=1,&j), Str1);
+    CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &n1, (j=1,&j), Str1);
 
-  freeArrayOfString(Str1,n1);
-  if (Str)
+    freeArrayOfString(Str1,n1);
+    if (Str)
     {
-      FREE(Str);
-      Str = NULL;
+        FREE(Str);
+        Str = NULL;
     }
 
-  LhsVar(1) = Rhs + 1;
-  PutLhsVar();
+    LhsVar(1) = Rhs + 1;
+    PutLhsVar();
 
-  return(0);
+    return(0);
 }
 /*--------------------------------------------------------------------------*/
index 8c6a19a..870c199 100644 (file)
@@ -1,14 +1,14 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006 - INRIA - Allan CORNET
- * 
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at    
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2006 - INRIA - Allan CORNET
+* 
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at    
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 
 #include "callfftw.h"
 #include "stack-c.h"
 /*--------------------------------------------------------------------------*/ 
 int sci_loadfftwlibrary(char *fname,unsigned long fname_len)
 {
-       static int l1,n1,m1;
-       char *FFTWLibname=NULL;
+    static int l1,n1,m1;
+    char *FFTWLibname=NULL;
 
-       CheckRhs(1,1);
+    CheckRhs(1,1);
 
-       if (GetType(1) == sci_strings)
-       {
-               GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-               FFTWLibname=cstk(l1);
-               setfftwlibname(FFTWLibname);
+    if (GetType(1) == sci_strings)
+    {
+        GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
+        FFTWLibname=cstk(l1);
+        setfftwlibname(FFTWLibname);
 
-               n1=1;
-               if ( LoadFFTWLibrary(FFTWLibname) )
-               {
-                       CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
-                       *istk(l1)=(int)(TRUE);
-               }
-               else
-               {
-                       CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
-                       *istk(l1)=(int)(FALSE);
-               }
+        n1=1;
+        if ( LoadFFTWLibrary(FFTWLibname) )
+        {
+            CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
+            *istk(l1)=(int)(TRUE);
+        }
+        else
+        {
+            CreateVar(Rhs+1,MATRIX_OF_BOOLEAN_DATATYPE, &n1,&n1,&l1);
+            *istk(l1)=(int)(FALSE);
+        }
 
-               LhsVar(1)=Rhs+1;
-               PutLhsVar();
-       }
-       else
-       {
-                Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"),fname,1);
-       }
-       return(0);
+        LhsVar(1)=Rhs+1;
+        PutLhsVar();
+    }
+    else
+    {
+        Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"),fname,1);
+    }
+    return(0);
 }
 /*--------------------------------------------------------------------------*/ 
index 7d7eb79..58e19a9 100644 (file)
@@ -1,15 +1,15 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2006/2007 - INRIA - Alan LAYEC
- * Copyright (C) 2007 - INRIA - Allan CORNET
- * 
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at    
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2006/2007 - INRIA - Alan LAYEC
+* Copyright (C) 2007 - INRIA - Allan CORNET
+* 
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at    
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 
 
 #include "callfftw.h"
 /*--------------------------------------------------------------------------*/
 
 /* Set fftw wisdom
- *
- * Scilab Calling sequence :
- *   -->set_fftw_wisdom(txt);
- *
- * Input : a scilab string matrix
- *
- * Output : Nothing or an error messsage if
- *          wisdom can't be read by fftw
- *
- */
+*
+* Scilab Calling sequence :
+*   -->set_fftw_wisdom(txt);
+*
+* Input : a scilab string matrix
+*
+* Output : Nothing or an error messsage if
+*          wisdom can't be read by fftw
+*
+*/
 int sci_set_fftw_wisdom(char *fname,unsigned long fname_len)
 {
 
-  if(withMKL()) {
-    Scierror(999,_("%s: MKL fftw library does not implement wisdom functions yet.\n"), fname);
-    return 0;
-  }
+    if(withMKL()) {
+        Scierror(999,_("%s: MKL fftw library does not implement wisdom functions yet.\n"), fname);
+        return 0;
+    }
 
-  CheckRhs(1,1);
+    CheckRhs(1,1);
 
-  if (VarType(1)==sci_strings)
+    if (VarType(1)==sci_strings)
     {
-      char **Str1 = NULL;
-      char *Str = NULL;
-      int m1 = 0, n1 = 0;
-      int len = 0, k = 0;
-      int j = 0;
+        char **Str1 = NULL;
+        char *Str = NULL;
+        int m1 = 0, n1 = 0;
+        int len = 0, k = 0;
+        int j = 0;
 
-      GetRhsVar(1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&Str1);
+        GetRhsVar(1,MATRIX_OF_STRING_DATATYPE,&m1,&n1,&Str1);
 
-      for (j = 0; j < m1*n1; j++)
+        for (j = 0; j < m1*n1; j++)
         {
-          int i = 0;
+            int i = 0;
 
-          len += (int)strlen(Str1[j])+1;
+            len += (int)strlen(Str1[j])+1;
 
-          if (Str) Str = (char *)REALLOC(Str,sizeof(char)*(len));
-          else Str = (char *)MALLOC(sizeof(char)*(len));
+            if (Str) Str = (char *)REALLOC(Str,sizeof(char)*(len));
+            else Str = (char *)MALLOC(sizeof(char)*(len));
 
-          if (Str == NULL)
+            if (Str == NULL)
             {
-              freeArrayOfString(Str1,m1*n1);
-              Scierror(999,_("%s: Cannot allocate more memory.\n"),fname);
-              return(0);
+                freeArrayOfString(Str1,m1*n1);
+                Scierror(999,_("%s: Cannot allocate more memory.\n"),fname);
+                return(0);
             }
 
-          for (i = 0; i < (int)strlen(Str1[j]); i++)
+            for (i = 0; i < (int)strlen(Str1[j]); i++)
             {
-              Str[k+i] = Str1[j][i];
+                Str[k+i] = Str1[j][i];
             }
-          Str[k+strlen(Str1[j])] = '\n';
-          k += (int)strlen(Str1[j])+1;
+            Str[k+strlen(Str1[j])] = '\n';
+            k += (int)strlen(Str1[j])+1;
         }
-      Str[k-1] = '\0';
+        Str[k-1] = '\0';
 
-      freeArrayOfString(Str1,m1*n1);
+        freeArrayOfString(Str1,m1*n1);
 
-      if(!(call_fftw_import_wisdom_from_string(Str)))
+        if(!(call_fftw_import_wisdom_from_string(Str)))
         {
-          FREE(Str); Str = NULL;
-          Scierror(999,_("%s: Wrong value for input argument #%d: a valid wisdom expected.\n"),fname,1);
-          return(0);
+            FREE(Str); Str = NULL;
+            Scierror(999,_("%s: Wrong value for input argument #%d: a valid wisdom expected.\n"),fname,1);
+            return(0);
         }
-      FREE(Str); Str = NULL;
+        FREE(Str); Str = NULL;
     }
-  else
+    else
     {
-      Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"),fname,1);
-      return(0);
+        Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"),fname,1);
+        return(0);
     }
 
-  LhsVar(1)= 0;
-  PutLhsVar();
-  return(0);
+    LhsVar(1)= 0;
+    PutLhsVar();
+    return(0);
 }
 /*--------------------------------------------------------------------------*/
index 22619e2..9c01d8c 100644 (file)
@@ -1,25 +1,25 @@
 /*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2007 - INRIA - Allan CORNET
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
+* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+* Copyright (C) 2007 - INRIA - Allan CORNET
+*
+* This file must be used under the terms of the CeCILL.
+* This source file is licensed as described in the file COPYING, which
+* you should have received as part of this distribution.  The terms
+* are also available at
+* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+*
+*/
 
 #include "with_fftw.h"
 /*--------------------------------------------------------------------------*/
 int C2F(withfftw)(int *rep)
 {
-  *rep = 1;
-  return 0;
+    *rep = 1;
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
 BOOL withfftw(void)
 {
-  return TRUE;
+    return TRUE;
 }
 /*--------------------------------------------------------------------------*/