scilab/modules/call_scilab/examples/call_scilab/c#/dotnetsci/dotnetsci/Scilab.cs

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2009 - DIGITEO - Allan CORNET
   4  *
   5  * This file must be used under the terms of the CeCILL.
   6  * This source file is licensed as described in the file COPYING, which
   7  * you should have received as part of this distribution.  The terms
   8  * are also available at
   9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  10  *
  11  */
  12 //=============================================================================
  13 using System;
  14 using System.Collections.Generic;
  15 using System.Linq;
  16 using System.Text;
  17 using System.Runtime.InteropServices;
  18 using System.Threading;
  19 //=============================================================================
  20 namespace DotNetScilab
  21 {
  22     public sealed class Scilab
  23     {
  24         //=============================================================================
  25         public enum ScilabType {
  26         sci_matrix = 1 ,
  27         sci_poly = 2 ,
  28         sci_boolean = 4 ,
  29         sci_sparse = 5  ,
  30         sci_boolean_sparse = 6,
  31         sci_matlab_sparse = 7, /* matlab sparse matrix  */
  32         sci_ints = 8,
  33         sci_handles = 9,
  34         sci_strings = 10,
  35         sci_u_function = 11,
  36         sci_c_function = 13 ,
  37         sci_lib =  14,
  38         sci_list = 15,
  39         sci_tlist = 16,
  40         sci_mlist = 17,
  41         sci_lufact_pointer = 128, /* lufact pointer */
  42         sci_implicit_poly = 129,
  43         sci_intrinsic_function = 130};
  44         //=============================================================================
  45         static Scilab instance = null;
  46         static readonly object padlock = new object();
  47         private Boolean withGraphics = false;
  48         //=============================================================================
  49         private const string CALL_SCILAB_DLL = "call_scilab.dll";
  50         private const string API_SCILAB_DLL = "api_scilab.dll";
  51         private const string GRAPHICS_DLL = "graphics.dll";
  52         private const string OUTPUT_STREAM_DLL = "scioutput_stream.dll";
  53         //=============================================================================
  54         /// <summary>
  55         /// Constructor, initialize scilab engine.
  56         /// </summary>
  57         public Scilab()
  58         {
  59             // start Scilab engine
  60             StartScilab(null, null, null);
  61             // Disable TCL/TK and Java graphic interfaces
  62             DisableInteractiveMode();
  63             withGraphics = false;
  64         }
  65         //=============================================================================
  66         public Scilab(Boolean _bWithGraphics)
  67         {
  68             // start Scilab engine
  69             StartScilab(null, null, null);
  70             // Disable TCL/TK and Java graphic interfaces
  71             if (_bWithGraphics == false)
  72             {
  73                 DisableInteractiveMode();
  74                 withGraphics = false;
  75             }
  76             else
  77             {
  78                 withGraphics = true;
  79             }
  80         }
  81         //=============================================================================
  82         /// <summary>
  83         /// Singleton
  84         /// Only one instance of Scilab can be launch
  85         /// thread safe
  86         /// </summary>
  87         public static Scilab Instance
  88         {
  89             get
  90             {
  91                 lock (padlock)
  92                 {
  93                     if (instance == null)
  94                     {
  95                         instance = new Scilab();
  96                     }
  97                     return instance;
  98                 }
  99             }
 100         }
 101         //=============================================================================
 102         /// <summary>
 103         /// Destructor
 104         /// </summary>
 105         ~Scilab()
 106         {
 107             finish();
 108         }
 109         //=============================================================================
 110         /// <summary>
 111         /// Send a job to scilab
 112         /// </summary>
 113         /// <param name="command">command to send to scilab</param>
 114         /// <returns>error code operation, 0 : OK</returns>
 115         public int sendScilabJob(string command)
 116         {
 117             return SendScilabJob(command);
 118         }
 119         //=============================================================================
 120         /// <summary>
 121         /// Write a named matrix of double in Scilab
 122         /// </summary>
 123         /// <param name="matrixName"> variable name</param>
 124         /// <param name="iRows"> Number of row</param>
 125         /// <param name="iCols"> Number of column</param>
 126         /// <param name="matrixDouble"> pointer on data</param>
 127         /// <returns> if the operation successes (0) or not ( !0 )</returns>
 128         public int setNamedMatrixOfDouble(string matrixName, int iRows, int iCols, double[] matrixDouble)
 129         {
 130             return createNamedMatrixOfDouble(matrixName, iRows, iCols, matrixDouble);
 131         }
 132         //=============================================================================
 133         /// <summary>
 134         /// Read a named matrix of double from Scilab
 135         /// </summary>
 136         /// <param name="matrixName"> variable name</param>
 137         /// <returns>a matrix of double from scilab. If Variable name does not exist returns null</returns>
 138         public unsafe double[] getNamedMatrixOfDouble(string matrixName)
 139         {
 140             // first , we want to known dimensions iRows and iCols
 141             int[] iDims = getNamedMatrixOfDoubleDimensions(matrixName);
 142             int iRows = iDims[0];
 143             int iCols = iDims[1];
 144
 145             // we allocate matrixDouble array
 146             if (iRows * iCols > 0)
 147             {
 148                 double[] matrixDouble = new double[iRows * iCols];
 149
 150                 // get values in matrixDouble
 151                 readNamedMatrixOfDouble(matrixName, &iRows, &iCols, matrixDouble);
 152
 153                 return matrixDouble;
 154             }
 155             return null;
 156         }
 157         //=============================================================================
 158         /// <summary>
 159         /// Get dimensions of a named matrix of double in scilab
 160         /// </summary>
 161         /// <returns>a int array. if variable name does not exist dimensions are 0 0 </returns>
 162         public unsafe int[] getNamedMatrixOfDoubleDimensions(string matrixName)
 163         {
 164             int iRows = 0;
 165             int iCols = 0;
 166             int[] iDim = new int[2];
 167
 168             readNamedMatrixOfDouble(matrixName, &iRows, &iCols, null);
 169
 170             iDim[0] = iRows;
 171             iDim[1] = iCols;
 172
 173             return iDim;
 174         }
 175         //=============================================================================
 176         /// <summary>
 177         /// Write a named matrix of string in scilab
 178         /// </summary>
 179         /// <param name="matrixName"> variable name</param>
 180         /// <param name="iRows"> Number of row</param>
 181         /// <param name="iCols"> Number of column</param>
 182         /// <param name="matrixDouble"> pointer on data</param>
 183         /// <returns> if the operation successes (0) or not ( !0 )</returns>
 184         public int setNamedMatrixOfString(string matrixName, int iRows, int iCols, string[] matrixString)
 185         {
 186             return createNamedMatrixOfString(matrixName, iRows, iCols, matrixString);
 187         }
 188         //=============================================================================
 189         /// <summary>
 190         /// Read a named matrix of string from scilab
 191         /// </summary>
 192         /// <param name="matrixName"> variable name</param>
 193         /// <returns>a matrix of string from scilab. If Variable name does not exist returns null</returns>
 194         public unsafe string[] getNamedMatrixOfString(string matrixName)
 195         {
 196             // first , we want to known dimensions iRows and iCols
 197             int[] iDim = getNamedMatrixOfStringDimensions(matrixName);
 198             int iRows = iDim[0];
 199             int iCols = iDim[1];
 200
 201             // we allocate lengthmatrixString
 202             int[] lengthmatrixString = new int[iRows * iCols];
 203             // we get length of strings
 204             readNamedMatrixOfString(matrixName, &iRows, &iCols, lengthmatrixString, null);
 205
 206             // we allocate each string
 207             string[] matrixString = new string[iRows * iCols];
 208             for (int i = 0; i < iRows * iCols; i++)
 209             {
 210                 matrixString[i] = new string(' ',lengthmatrixString[i]);
 211             }
 212             // we get strings from scilab
 213             readNamedMatrixOfString(matrixName, &iRows, &iCols, lengthmatrixString, matrixString);
 214
 215             return matrixString;
 216         }
 217         //=============================================================================
 218         /// <summary>
 219         /// Get dimensions of a named matrix of string in scilab
 220         /// </summary>
 221         /// <returns>a int array. if variable name does not exist dimensions are 0 0 </returns>
 222         public unsafe int[] getNamedMatrixOfStringDimensions(string matrixName)
 223         {
 224             int iRows = 0;
 225             int iCols = 0;
 226             int[] iDim = new int[2];
 227
 228             readNamedMatrixOfString(matrixName, &iRows, &iCols, null, null);
 229
 230             iDim[0] = iRows;
 231             iDim[1] = iCols;
 232
 233             return iDim;
 234         }
 235         //=============================================================================
 236         /// <summary>
 237         /// Write a named matrix of boolean in Scilab
 238         /// </summary>
 239         /// <param name="matrixName"> variable name</param>
 240         /// <param name="iRows"> Number of row</param>
 241         /// <param name="iCols"> Number of column</param>
 242         /// <param name="matrixBoolean"> pointer on data</param>
 243         /// <returns> if the operation successes (0) or not ( !0 )</returns>
 244         public int setNamedMatrixOfBoolean(string matrixName, int iRows, int iCols, Boolean[] matrixBoolean)
 245         {
 246             int[] matrixInt = new int[matrixBoolean.Length];
 247             for (int i = 0; i< matrixBoolean.Length; i++)
 248             {
 249                 if (matrixBoolean[i] == true)
 250                 {
 251                     matrixInt[i] = 1;
 252                 }
 253                 else
 254                 {
 255                     matrixInt[i] = 0;
 256                 }
 257             }
 258             return createNamedMatrixOfBoolean(matrixName, iRows, iCols, matrixInt);
 259         }
 260         //=============================================================================
 261         /// <summary>
 262         /// Read a named matrix of boolean from Scilab
 263         /// </summary>
 264         /// <param name="matrixName"> variable name</param>
 265         /// <returns>a matrix of boolean from scilab. If Variable name does not exist returns null</returns>
 266         public unsafe Boolean[] getNamedMatrixOfBoolean(string matrixName)
 267         {
 268             // first , we want to known dimensions iRows and iCols
 269             int[] iDim = getNamedMatrixOfBooleanDimensions(matrixName);
 270             int iRows = iDim[0];
 271             int iCols = iDim[1];
 272
 273             // we allocate matrixInt array
 274             if (iRows * iCols > 0)
 275             {
 276                 int[] matrixInt = new int[iRows * iCols];
 277
 278                 // get values in matrixDouble
 279                 readNamedMatrixOfBoolean(matrixName, &iRows, &iCols, matrixInt);
 280
 281                 Boolean[] matrixBoolean = new Boolean[iRows * iCols];
 282                 for (int i = 0; i < iRows * iCols; i++ )
 283                 {
 284                     if (matrixInt[i] == 1)
 285                     {
 286                         matrixBoolean[i] = true;
 287                     }
 288                     else
 289                     {
 290                         matrixBoolean[i] = false;
 291                     }
 292                 }
 293                 return matrixBoolean;
 294             }
 295             return null;
 296         }
 297         //=============================================================================
 298         /// <summary>
 299         /// Get dimensions of a named matrix of boolean in scilab
 300         /// </summary>
 301         /// <param name="matrixName"> variable name</param>
 302         /// <returns>a int array. if variable name does not exist dimensions are 0 0 </returns>
 303         public unsafe int[] getNamedMatrixOfBooleanDimensions(string matrixName)
 304         {
 305             int iRows = 0;
 306             int iCols = 0;
 307             int[] iDim = new int[2];
 308
 309             readNamedMatrixOfBoolean(matrixName, &iRows, &iCols, null);
 310
 311             iDim[0] = iRows;
 312             iDim[1] = iCols;
 313
 314             return iDim;
 315         }
 316         //=============================================================================
 317         /// <summary>
 318         /// Write a named matrix of int(32) in Scilab
 319         /// </summary>
 320         /// <param name="matrixName"> variable name</param>
 321         /// <param name="iRows"> Number of row</param>
 322         /// <param name="iCols"> Number of column</param>
 323         /// <param name="matrixInt"> pointer on data</param>
 324         public int setNamedMatrixOfInt(string matrixName, int iRows, int iCols, int[] matrixInt)
 325         {
 326             return createNamedMatrixOfInteger32(matrixName, iRows, iCols, matrixInt);
 327         }
 328         //=============================================================================
 329         /// <summary>
 330         /// Read a named matrix of int(32) in Scilab
 331         /// </summary>
 332         /// <param name="matrixName"> variable name</param>
 333         /// <returns>a matrix of int(32) from scilab. If Variable name does not exist returns null</returns>
 334         public unsafe int[] getNamedMatrixOfInt(string matrixName)
 335         {
 336             // first , we want to known dimensions iRows and iCols
 337             int[] iDim = getNamedMatrixOfIntDimensions(matrixName);
 338             int iRows = iDim[0];
 339             int iCols = iDim[1];
 340
 341             // we allocate matrixInt array
 342             if (iRows * iCols > 0)
 343             {
 344                 int[] matrixInt = new int[iRows * iCols];
 345
 346                 // get values in matrixInt
 347                 readNamedMatrixOfInteger32(matrixName, &iRows, &iCols, matrixInt);
 348                 return matrixInt;
 349             }
 350             return null;
 351         }
 352         //=============================================================================
 353         /// <summary>
 354         /// Get dimensions of a named matrix of int(32) in scilab
 355         /// </summary>
 356         /// <param name="matrixName"> variable name</param>
 357         /// <returns>a int array. if variable name does not exist dimensions are 0 0 </returns>
 358         public unsafe int[] getNamedMatrixOfIntDimensions(string matrixName)
 359         {
 360             int iRows = 0;
 361             int iCols = 0;
 362             int[] iDim = new int[2];
 363
 364             readNamedMatrixOfInteger32(matrixName, &iRows, &iCols, null);
 365
 366             iDim[0] = iRows;
 367             iDim[1] = iCols;
 368
 369             return iDim;
 370         }
 371         //=============================================================================
 372         /// <summary>
 373         /// Write a named matrix of complex double in Scilab
 374         /// </summary>
 375         /// <param name="matrixName"> variable name</param>
 376         /// <param name="iRows">Number of row</param>
 377         /// <param name="iCols">Number of column</param>
 378         /// <param name="matrixRealPart">real part</param>
 379         /// <param name="matrixImagPart">imag part</param>
 380         /// <returns></returns>
 381         public int setNamedMatrixOfComplexDouble(string matrixName,
 382                                                 int iRows, int iCols,
 383                                                 double[] matrixRealPart,
 384                                                 double[] matrixImagPart)
 385         {
 386             return createNamedComplexMatrixOfDouble(matrixName,
 387                                                     iRows, iCols,
 388                                                     matrixRealPart,
 389                                                     matrixImagPart);
 390         }
 391         //=============================================================================
 392         /// <summary>
 393         /// Read a named matrix of complex double in Scilab (Real part)
 394         /// </summary>
 395         /// <param name="matrixName">variable name</param>
 396         /// <returns> real part</returns>
 397         public unsafe double[] getNamedMatrixOfComplexDoubleRealPart(string matrixName)
 398         {
 399             int[] iDim = getNamedMatrixOfComplexDoubleDimensions(matrixName);
 400             int iRows = iDim[0];
 401             int iCols = iDim[1];
 402             double[] dRealPart = new double[iRows * iCols];
 403             double[] dImagPart = new double[iRows * iCols];
 404
 405             readNamedComplexMatrixOfDouble(matrixName,
 406                                            &iRows, &iCols,
 407                                            dRealPart,
 408                                            dImagPart);
 409
 410             return dRealPart;
 411         }
 412         //=============================================================================
 413         /// <summary>
 414         /// Read a named matrix of complex double in Scilab (Imag part)
 415         /// </summary>
 416         /// <param name="matrixName">variable name</param>
 417         /// <returns>imag part</returns>
 418         public unsafe double[] getNamedMatrixOfComplexDoubleImagPart(string matrixName)
 419         {
 420             int[] iDim = getNamedMatrixOfComplexDoubleDimensions(matrixName);
 421             int iRows = iDim[0];
 422             int iCols = iDim[1];
 423             double[] dRealPart = new double[iRows * iCols];
 424             double[] dImagPart = new double[iRows * iCols];
 425
 426             readNamedComplexMatrixOfDouble(matrixName,
 427                                &iRows, &iCols,
 428                                dRealPart,
 429                                dImagPart);
 430             return dImagPart;
 431         }
 432         //=============================================================================
 433         /// <summary>
 434         /// Get dimensions of a matrix of complex double in scilab
 435         /// </summary>
 436         /// <param name="matrixName">variable name</param>
 437         /// <returns>dimension</returns>
 438         public unsafe int[] getNamedMatrixOfComplexDoubleDimensions(string matrixName)
 439         {
 440             int iRows = 0;
 441             int iCols = 0;
 442             int[] iDim = new int[2];
 443
 444             readNamedComplexMatrixOfDouble(matrixName, &iRows, &iCols, null,null);
 445
 446             iDim[0] = iRows;
 447             iDim[1] = iCols;
 448
 449             return iDim;
 450         }
 451         //=============================================================================
 452         /// <summary>
 453         /// get scilab type of named matrix
 454         /// </summary>
 455         /// <param name="matrixName"> variable name</param>
 456         /// <returns>scilab type (see enum ScilabType)</returns>
 457         public unsafe int getNamedMatrixType(string matrixName)
 458         {
 459             int* piAdress = null;
 460             getVarAddressFromName(matrixName, &piAdress);
 461             return getVarType(piAdress);
 462         }
 463         //=============================================================================
 464         /// <summary>
 465         /// Detect if a variable name exists in Scilab
 466         /// </summary>
 467         /// <param name="matrixName"> variable name</param>
 468         /// <returns> true if exists</returns>
 469         public unsafe Boolean existNamedVariable(string matrixName)
 470         {
 471             int* piAdress = null;
 472             int ierr = getVarAddressFromName(matrixName, &piAdress);
 473             if ( (ierr == 1) && (piAdress != null)) return true;
 474             return false;
 475         }
 476         //=============================================================================
 477         /// <summary>
 478         /// Execute a scilab script .sce
 479         /// </summary>
 480         /// <param name="scriptFilename">the path to the .sce file</param>
 481         /// <returns>error code operation, 0 : OK</returns>
 482         public int execScilabScript(String scriptFilename)
 483         {
 484             return sendScilabJob( "exec('" + scriptFilename + "');" );
 485         }
 486         //=============================================================================
 487         /// <summary>
 488         /// Detect if a Scilab graphic window is opened
 489         /// </summary>
 490         /// <returns>true or false</returns>
 491         public Boolean HaveAGraph()
 492         {
 493             if (withGraphics)
 494             {
 495                 int ierr = sciHasFigures();
 496                 if (ierr == 1) return true;
 497             }
 498             return false;
 499         }
 500         //=============================================================================
 501         /// <summary>
 502         /// do a scilab event
 503         /// parser need to run to do a event
 504         /// </summary>
 505         /// <returns>error code operation, 0 : OK</returns>
 506         public int doEvent()
 507         {
 508             // do a pause (we do not want 100% CPU used)
 509             // ugly but it works ...
 510             Thread.Sleep(1);
 511             // do a loop of parser
 512             return sendScilabJob("");
 513         }
 514         //=============================================================================
 515         /// <summary>
 516         /// Terminate Scilab engine.
 517         /// </summary>
 518         /// <returns>1 if it is correctly finished</returns>
 519         private int finish()
 520         {
 521             int ierr = TerminateScilab(null);
 522             return ierr;
 523         }
 524         //=============================================================================
 525         /// <summary>
 526         /// import SendScilabJob from C (see CallScilab.h)
 527         /// </summary>
 528         [DllImport(CALL_SCILAB_DLL, CharSet = CharSet.Ansi)]
 529         private static extern int SendScilabJob([In]String job);
 530         //=============================================================================
 531         /// <summary>
 532         /// import StartScilab from C (see CallScilab.h)
 533         /// </summary>
 534         [DllImport(CALL_SCILAB_DLL, CharSet = CharSet.Ansi)]
 535         private static extern int StartScilab([In] String SCIpath,
 536                                               [In] String ScilabStartup,
 537                                               [In] Int32[] Stacksize);
 538         //=============================================================================
 539         /// <summary>
 540         /// import TerminateScilab from C (see CallScilab.h)
 541         /// </summary>
 542         [DllImport(CALL_SCILAB_DLL, CharSet = CharSet.Ansi)]
 543         private static extern int TerminateScilab([In] String ScilabQuit);
 544         //=============================================================================
 545         /// <summary>
 546         /// import DisableInteractiveMode from C (see CallScilab.h)
 547         /// </summary>
 548         [DllImport(CALL_SCILAB_DLL, CharSet = CharSet.Ansi)]
 549         private static extern void DisableInteractiveMode();
 550         //=============================================================================
 551         /// <summary>
 552         /// import createNamedMatrixOfString from C (see api_string.h)
 553         /// </summary>
 554         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 555         private static extern int createNamedMatrixOfString([In] String _pstName,
 556                                                             [In] int _iRows, [In] int _iCols,
 557                                                             [In] String[] _pstStrings);
 558         //=============================================================================
 559         /// <summary>
 560         /// import createNamedMatrixOfDouble from C (see api_double.h)
 561         /// </summary>
 562         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 563         private static extern int createNamedMatrixOfDouble([In] String _pstName,
 564                                                             [In] int _iRows, [In] int _iCols,
 565                                                             [In] double[] _pdblReal);
 566         //=============================================================================
 567         /// <summary>
 568         /// import createNamedMatrixOfBoolean from C (see api_boolean.h)
 569         /// </summary>
 570         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 571         private static extern int createNamedMatrixOfBoolean([In] String _pstName,
 572                                                             [In] int _iRows, [In] int _iCols,
 573                                                             [In] int[] _piBool);
 574         //=============================================================================
 575         /// <summary>
 576         /// import createNamedMatrixOfInteger32 from C (see api_int.h)
 577         /// </summary>
 578         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 579         private unsafe static extern int createNamedMatrixOfInteger32([In] String _pstName,
 580                                                            [In] int _iRows, [In] int _iCols,
 581                                                            [In] int[] _piData);
 582         //=============================================================================
 583         /// <summary>
 584         /// import createNamedComplexMatrixOfDouble from C (see api_double.h)
 585         /// </summary>
 586         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 587         private unsafe static extern int createNamedComplexMatrixOfDouble([In] String _pstName,
 588                                                             [In] int _iRows, [In] int _iCols,
 589                                                             [In] double[] _pdblReal,
 590                                                             [In] double[] _pdblImg);
 591         //=============================================================================
 592         /// <summary>
 593         /// import readNamedMatrixOfString from C (see api_string.h)
 594         /// </summary>
 595         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 596         private unsafe static extern int readNamedMatrixOfString([In] String _pstName,
 597                                                           [Out]  Int32* _piRows, [Out]  Int32* _piCols,
 598                                                           [In, Out] int[] _piLength,
 599                                                           [In, Out] String[] _pstStrings);
 600         //=============================================================================
 601         /// <summary>
 602         /// import readNamedMatrixOfDouble from C (see api_double.h)
 603         /// </summary>
 604         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 605         private unsafe static extern int readNamedMatrixOfDouble([In] String _pstName,
 606                                                           [Out] Int32* _piRows, [Out] Int32* _piCols,
 607                                                           [In, Out] Double[] _pdblReal);
 608         //=============================================================================
 609         /// <summary>
 610         /// import readNamedMatrixOfBoolean from C (see api_boolean.h)
 611         /// </summary>
 612         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 613         private unsafe static extern int readNamedMatrixOfBoolean([In] String _pstName,
 614                                                           [Out] Int32* _piRows, [Out] Int32* _piCols,
 615                                                           [In, Out] int[] _piBool);
 616         //=============================================================================
 617         /// <summary>
 618         /// import readNamedMatrixOfInteger32 from C (see api_int.h)
 619         /// </summary>
 620         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 621         private unsafe static extern int readNamedMatrixOfInteger32([In] String _pstName,
 622                                                           [Out] Int32* _piRows, [Out] Int32* _piCols,
 623                                                           [In, Out] int[] _piData);
 624
 625         //=============================================================================
 626         /// <summary>
 627         /// import readNamedComplexMatrixOfDouble from C (see api_double.h)
 628         /// </summary>
 629         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 630         private unsafe static extern int readNamedComplexMatrixOfDouble([In] String _pstName,
 631                                                         [Out] Int32* _piRows, [Out] Int32* _piCols,
 632                                                         [In, Out] double[] _pdblReal,
 633                                                         [In, Out] double[] _pdblImg);
 634         //=============================================================================
 635         /// <summary>
 636         /// get Variable Adress in scilab stack from name
 637         /// used for getNamedMatrixType (internal)
 638         /// </summary>
 639         /// <param name="_pstName">variable name</param>
 640         /// <param name="_piAddress"> stack address</param>
 641         /// <returns>1 if ok</returns>
 642         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 643         private unsafe static extern int getVarAddressFromName([In] String _pstName,
 644                                                                [Out] Int32** _piAddress);
 645         //=============================================================================
 646         /// <summary>
 647         /// get variable type with adress in scilab stack
 648         /// used for getNamedMatrixType (internal)
 649         /// </summary>
 650         /// <param name="_piAddress"> stack address</param>
 651         /// <returns>scilab type, 0 fails</returns>
 652         [DllImport(API_SCILAB_DLL, CharSet = CharSet.Ansi)]
 653         private unsafe static extern int getVarType([In] Int32* _piAddress);
 654         //=============================================================================
 655         /// <summary>
 656         ///  Detect if a Scilab graphic window is opened
 657         /// </summary>
 658         /// <returns>0 (FALSE) or 1 (TRUE)</returns>
 659         [DllImport(GRAPHICS_DLL, CharSet = CharSet.Ansi)]
 660         private unsafe static extern int sciHasFigures();
 661         //=============================================================================
 662         /// <summary>
 663         ///  get last error code
 664         /// </summary>
 665         /// <returns>last error code</returns>
 666         [DllImport(OUTPUT_STREAM_DLL, CharSet = CharSet.Ansi)]
 667         public unsafe static extern int GetLastErrorCode();
 668         //=============================================================================
 669     }
 670 }
 671 //=============================================================================