extends example
Allan CORNET [Sun, 5 Jul 2009 09:48:55 +0000 (11:48 +0200)]
scilab/modules/call_scilab/examples/call_scilab/c#/dotnetsci/dotnetsci/DotNetScilab.csproj
scilab/modules/call_scilab/examples/call_scilab/c#/dotnetsci/dotnetsci/Scilab.cs
scilab/modules/call_scilab/examples/call_scilab/c#/dotnetsci/example/example.cs

index 4b56094..640bb8e 100644 (file)
@@ -3,7 +3,7 @@
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
     <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
-    <ProductVersion>9.0.30729</ProductVersion>
+    <ProductVersion>9.0.21022</ProductVersion>
     <SchemaVersion>2.0</SchemaVersion>
     <ProjectGuid>{C3F0C7DC-82AD-405B-990A-BF2C5B7F46FF}</ProjectGuid>
     <OutputType>Library</OutputType>
index 54e7caf..a6db624 100644 (file)
@@ -15,15 +15,41 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Runtime.InteropServices;
+using System.Threading;
 //=============================================================================
 namespace DotNetScilab
 {
-    public class Scilab
+    public sealed class Scilab
     {
         //=============================================================================
+        public enum ScilabType { 
+        sci_matrix = 1 ,
+        sci_poly = 2 ,
+        sci_boolean = 4 ,
+        sci_sparse = 5  ,
+        sci_boolean_sparse = 6,
+        sci_matlab_sparse = 7, /* matlab sparse matrix  */
+        sci_ints = 8,
+        sci_handles = 9,
+        sci_strings = 10,
+        sci_u_function = 11,
+        sci_c_function = 13 ,
+        sci_lib =  14,
+        sci_list = 15,
+        sci_tlist = 16,
+        sci_mlist = 17,
+        sci_lufact_pointer = 128, /* lufact pointer */
+        sci_implicit_poly = 129,
+        sci_intrinsic_function = 130};
+        //=============================================================================
+        static Scilab instance = null;
+        static readonly object padlock = new object();
+        private Boolean withGraphics = false;
+        //=============================================================================
         private const string CALL_SCILAB_DLL = "call_scilab.dll";
         private const string LIBSCILAB_DLL = "libscilab.dll";
-        //private bool initialized = false;
+        private const string GRAPHICS_DLL = "graphics.dll";
+        private const string OUTPUT_STREAM_DLL = "scioutput_stream.dll";
         //=============================================================================
         /// <summary>
         /// Constructor, initialize scilab engine.
@@ -34,16 +60,51 @@ namespace DotNetScilab
             StartScilab(null, null, null);
             // Disable TCL/TK and Java graphic interfaces
             DisableInteractiveMode();
+            withGraphics = false;
+        }
+        //=============================================================================
+        public Scilab(Boolean _bWithGraphics)
+        {
+            // start Scilab engine
+            StartScilab(null, null, null);
+            // Disable TCL/TK and Java graphic interfaces
+            if (_bWithGraphics == false)
+            {
+                DisableInteractiveMode();
+                withGraphics = false;
+            }
+            else
+            {
+                withGraphics = true;
+            }
         }
         //=============================================================================
         /// <summary>
-        /// Terminate Scilab engine.
+        /// Singleton 
+        /// Only one instance of Scilab can be launch
+        /// thread safe
         /// </summary>
-        /// <returns>1 if it is correctly finished</returns>
-        public int finish()
+        public static Scilab Instance
         {
-            int ierr = TerminateScilab(null);
-            return ierr;
+            get
+            {
+                lock (padlock)
+                {
+                    if (instance == null)
+                    {
+                        instance = new Scilab();
+                    }
+                    return instance;
+                }
+            }
+        }
+        //=============================================================================
+        /// <summary>
+        /// Destructor
+        /// </summary>
+        ~Scilab()
+        {
+            finish();
         }
         //=============================================================================
         /// <summary>
@@ -82,6 +143,7 @@ namespace DotNetScilab
             double[] matrixDouble = new double[0];
             // first , we want to known dimensions iRows and iCols
             readNamedMatrixOfDouble(matrixName, &iRows , &iCols, matrixDouble);
+
             // we allocate matrixDouble array
             if (iRows * iCols > 0)
             {
@@ -175,6 +237,297 @@ namespace DotNetScilab
         }
         //=============================================================================
         /// <summary>
+        /// Write a named matrix of boolean in Scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <param name="iRows"> Number of row</param>
+        /// <param name="iCols"> Number of column</param>
+        /// <param name="matrixBoolean"> pointer on data</param>
+        /// <returns> if the operation successes (0) or not ( !0 )</returns>
+        public int setNamedMatrixOfBoolean(string matrixName, int iRows, int iCols, Boolean[] matrixBoolean)
+        {
+            int[] matrixInt = new int[matrixBoolean.Length];
+            for (int i = 0; i< matrixBoolean.Length; i++)
+            {
+                if (matrixBoolean[i] == true)
+                {
+                    matrixInt[i] = 1;
+                }
+                else
+                {
+                    matrixInt[i] = 0;
+                }
+            }
+            return createNamedMatrixOfBoolean(matrixName, iRows, iCols, matrixInt);
+        }
+        //=============================================================================
+        /// <summary>
+        /// Read a named matrix of boolean from Scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <returns>a matrix of boolean from scilab. If Variable name does not exist returns null</returns>
+        public unsafe Boolean[] getNamedMatrixOfBoolean(string matrixName)
+        {
+            int iRows = 0;
+            int iCols = 0;
+
+            int[] matrixInt = new int[0];
+            // first , we want to known dimensions iRows and iCols
+            readNamedMatrixOfBoolean(matrixName, &iRows, &iCols, matrixInt);
+            // we allocate matrixInt array
+            if (iRows * iCols > 0)
+            {
+                matrixInt = new int[iRows * iCols];
+
+                // get values in matrixDouble
+                readNamedMatrixOfBoolean(matrixName, &iRows, &iCols, matrixInt);
+
+                Boolean[] matrixBoolean = new Boolean[iRows * iCols];
+                for (int i = 0; i < iRows * iCols; i++ )
+                {
+                    if (matrixInt[i] == 1)
+                    {
+                        matrixBoolean[i] = true;
+                    }
+                    else
+                    {
+                        matrixBoolean[i] = false;
+                    }
+                }
+                return matrixBoolean;
+            }
+            return null;
+        }
+        //=============================================================================
+        /// <summary>
+        /// Get dimensions of a named matrix of boolean in scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <returns>a int array. if variable name does not exist dimensions are 0 0 </returns>
+        public unsafe int[] getNamedMatrixOfBooleanDimensions(string matrixName)
+        {
+            int iRows = 0;
+            int iCols = 0;
+            int[] iDim = new int[2];
+
+            readNamedMatrixOfBoolean(matrixName, &iRows, &iCols, null);
+
+            iDim[0] = iRows;
+            iDim[1] = iCols;
+
+            return iDim;
+        }
+        //=============================================================================
+        /// <summary>
+        /// Write a named matrix of int(32) in Scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <param name="iRows"> Number of row</param>
+        /// <param name="iCols"> Number of column</param>
+        /// <param name="matrixInt"> pointer on data</param>
+        public int setNamedMatrixOfInt(string matrixName, int iRows, int iCols, int[] matrixInt)
+        {
+            return createNamedMatrixOfInteger32(matrixName, iRows, iCols, matrixInt);
+        }
+        //=============================================================================
+        /// <summary>
+        /// Read a named matrix of int(32) in Scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <returns>a matrix of int(32) from scilab. If Variable name does not exist returns null</returns>
+        public unsafe int[] getNamedMatrixOfInt(string matrixName)
+        {
+            int iRows = 0;
+            int iCols = 0;
+
+            int[] matrixInt = new int[0];
+            // first , we want to known dimensions iRows and iCols
+            readNamedMatrixOfInteger32(matrixName, &iRows, &iCols, matrixInt);
+            // we allocate matrixInt array
+            if (iRows * iCols > 0)
+            {
+                matrixInt = new int[iRows * iCols];
+
+                // get values in matrixInt
+                readNamedMatrixOfInteger32(matrixName, &iRows, &iCols, matrixInt);
+                return matrixInt;
+            }
+            return null;
+        }
+        //=============================================================================
+        /// <summary>
+        /// Get dimensions of a named matrix of int(32) in scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <returns>a int array. if variable name does not exist dimensions are 0 0 </returns>
+        public unsafe int[] getNamedMatrixOfIntDimensions(string matrixName)
+        {
+            int iRows = 0;
+            int iCols = 0;
+            int[] iDim = new int[2];
+
+            readNamedMatrixOfInteger32(matrixName, &iRows, &iCols, null);
+
+            iDim[0] = iRows;
+            iDim[1] = iCols;
+
+            return iDim;
+        }
+        //=============================================================================
+        /// <summary>
+        /// Write a named matrix of complex double in Scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <param name="iRows">Number of row</param>
+        /// <param name="iCols">Number of column</param>
+        /// <param name="matrixRealPart">real part</param>
+        /// <param name="matrixImagPart">imag part</param>
+        /// <returns></returns>
+        public int setNamedMatrixOfComplexDouble(string matrixName,
+                                                int iRows, int iCols,
+                                                double[] matrixRealPart,
+                                                double[] matrixImagPart)
+        {
+            return createNamedComplexMatrixOfDouble(matrixName,
+                                                    iRows, iCols,
+                                                    matrixRealPart,
+                                                    matrixImagPart);
+        }
+        //=============================================================================
+        /// <summary>
+        /// Read a named matrix of complex double in Scilab (Real part)
+        /// </summary>
+        /// <param name="matrixName">variable name</param>
+        /// <returns> real part</returns>
+        public unsafe double[] getNamedMatrixOfComplexDoubleRealPart(string matrixName)
+        {
+            int[] iDim = getNamedMatrixOfComplexDoubleDimensions(matrixName);
+            int iRows = iDim[0];
+            int iCols = iDim[1];
+            double[] dRealPart = new double[iRows * iCols];
+            double[] dImagPart = new double[iRows * iCols];
+
+            readNamedComplexMatrixOfDouble(matrixName,
+                                           &iRows, &iCols,
+                                           dRealPart,
+                                           dImagPart);
+
+            return dRealPart;
+        }
+        //=============================================================================
+        /// <summary>
+        /// Read a named matrix of complex double in Scilab (Imag part)
+        /// </summary>
+        /// <param name="matrixName">variable name</param>
+        /// <returns>imag part</returns>
+        public unsafe double[] getNamedMatrixOfComplexDoubleImagPart(string matrixName)
+        {
+            int[] iDim = getNamedMatrixOfComplexDoubleDimensions(matrixName);
+            int iRows = iDim[0];
+            int iCols = iDim[1];
+            double[] dRealPart = new double[iRows * iCols];
+            double[] dImagPart = new double[iRows * iCols];
+
+            readNamedComplexMatrixOfDouble(matrixName,
+                               &iRows, &iCols,
+                               dRealPart,
+                               dImagPart);
+            return dImagPart;
+        }
+        //=============================================================================
+        /// <summary>
+        /// Get dimensions of a matrix of complex double in scilab
+        /// </summary>
+        /// <param name="matrixName">variable name</param>
+        /// <returns>dimension</returns>
+        public unsafe int[] getNamedMatrixOfComplexDoubleDimensions(string matrixName)
+        {
+            int iRows = 0;
+            int iCols = 0;
+            int[] iDim = new int[2];
+
+            readNamedComplexMatrixOfDouble(matrixName, &iRows, &iCols, null,null);
+
+            iDim[0] = iRows;
+            iDim[1] = iCols;
+
+            return iDim;
+        }
+        //=============================================================================
+        /// <summary>
+        /// get scilab type of named matrix
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <returns>scilab type (see enum ScilabType)</returns>
+        public unsafe int getNamedMatrixType(string matrixName)
+        {
+            int* piAdress = null;
+            getVarAddressFromName(matrixName, &piAdress);
+            return getVarType(piAdress);
+        }
+        //=============================================================================
+        /// <summary>
+        /// Detect if a variable name exists in Scilab
+        /// </summary>
+        /// <param name="matrixName"> variable name</param>
+        /// <returns> true if exists</returns>
+        public unsafe Boolean existNamedVariable(string matrixName)
+        {
+            int* piAdress = null;
+            int ierr = getVarAddressFromName(matrixName, &piAdress);
+            if ( (ierr == 1) && (piAdress != null)) return true;
+            return false;
+        }
+        //=============================================================================
+        /// <summary>
+        /// Execute a scilab script .sce
+        /// </summary>
+        /// <param name="scriptFilename">the path to the .sce file</param>
+        /// <returns>error code operation, 0 : OK</returns>
+        public int execScilabScript(String scriptFilename)
+        {
+            return sendScilabJob( "exec('" + scriptFilename + "');" );
+        }
+        //=============================================================================
+        /// <summary>
+        /// Detect if a Scilab graphic window is opened
+        /// </summary>
+        /// <returns>true or false</returns>
+        public Boolean HaveAGraph()
+        {
+            if (withGraphics)
+            {
+                int ierr = sciHasFigures();
+                if (ierr == 1) return true;
+            }
+            return false;
+        }
+        //=============================================================================
+        /// <summary>
+        /// do a scilab event
+        /// parser need to run to do a event
+        /// </summary>
+        /// <returns>error code operation, 0 : OK</returns>
+        public int doEvent()
+        {
+            // do a pause (we do not want 100% CPU used)
+            // ugly but it works ...
+            Thread.Sleep(1);
+            // do a loop of parser
+            return sendScilabJob("");
+        }
+        //=============================================================================
+        /// <summary>
+        /// Terminate Scilab engine.
+        /// </summary>
+        /// <returns>1 if it is correctly finished</returns>
+        private int finish()
+        {
+            int ierr = TerminateScilab(null);
+            return ierr;
+        }
+        //=============================================================================
+        /// <summary>
         /// import SendScilabJob from C (see CallScilab.h)
         /// </summary>
         [DllImport(CALL_SCILAB_DLL, CharSet = CharSet.Ansi)]
@@ -217,6 +570,31 @@ namespace DotNetScilab
                                                             [In] double[] _pdblReal);
         //=============================================================================
         /// <summary>
+        /// import createNamedMatrixOfBoolean from C (see api_boolean.h)
+        /// </summary>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private static extern int createNamedMatrixOfBoolean([In] String _pstName,
+                                                            [In] int _iRows, [In] int _iCols,
+                                                            [In] int[] _piBool);
+        //=============================================================================
+        /// <summary>
+        /// import createNamedMatrixOfInteger32 from C (see api_int.h)
+        /// </summary>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int createNamedMatrixOfInteger32([In] String _pstName,
+                                                           [In] int _iRows, [In] int _iCols,
+                                                           [In] int[] _piData);
+        //=============================================================================
+        /// <summary>
+        /// import createNamedComplexMatrixOfDouble from C (see api_double.h)
+        /// </summary>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int createNamedComplexMatrixOfDouble([In] String _pstName,
+                                                            [In] int _iRows, [In] int _iCols,
+                                                            [In] double[] _pdblReal,
+                                                            [In] double[] _pdblImg);
+        //=============================================================================
+        /// <summary>
         /// import readNamedMatrixOfString from C (see api_string.h)
         /// </summary>
         [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
@@ -233,6 +611,66 @@ namespace DotNetScilab
                                                           [Out] Int32* _piRows, [Out] Int32* _piCols,
                                                           [In, Out] Double[] _pdblReal);
         //=============================================================================
+        /// <summary>
+        /// import readNamedMatrixOfBoolean from C (see api_boolean.h)
+        /// </summary>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int readNamedMatrixOfBoolean([In] String _pstName,
+                                                          [Out] Int32* _piRows, [Out] Int32* _piCols,
+                                                          [In, Out] int[] _piBool);
+        //=============================================================================
+        /// <summary>
+        /// import readNamedMatrixOfInteger32 from C (see api_int.h)
+        /// </summary>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int readNamedMatrixOfInteger32([In] String _pstName,
+                                                          [Out] Int32* _piRows, [Out] Int32* _piCols,
+                                                          [In, Out] int[] _piData);
+
+        //=============================================================================
+        /// <summary>
+        /// import readNamedComplexMatrixOfDouble from C (see api_double.h)
+        /// </summary>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int readNamedComplexMatrixOfDouble([In] String _pstName,
+                                                        [Out] Int32* _piRows, [Out] Int32* _piCols,
+                                                        [In, Out] double[] _pdblReal,
+                                                        [In, Out] double[] _pdblImg);
+        //=============================================================================
+        /// <summary>
+        /// get Variable Adress in scilab stack from name
+        /// used for getNamedMatrixType (internal)
+        /// </summary>
+        /// <param name="_pstName">variable name</param>
+        /// <param name="_piAddress"> stack address</param>
+        /// <returns>1 if ok</returns>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int getVarAddressFromName([In] String _pstName,
+                                                               [Out] Int32** _piAddress);
+        //=============================================================================
+        /// <summary>
+        /// get variable type with adress in scilab stack
+        /// used for getNamedMatrixType (internal)
+        /// </summary>
+        /// <param name="_piAddress"> stack address</param>
+        /// <returns>scilab type, 0 fails</returns>
+        [DllImport(LIBSCILAB_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int getVarType([In] Int32* _piAddress);
+        //=============================================================================
+        /// <summary>
+        ///  Detect if a Scilab graphic window is opened
+        /// </summary>
+        /// <returns>0 (FALSE) or 1 (TRUE)</returns>
+        [DllImport(GRAPHICS_DLL, CharSet = CharSet.Ansi)]
+        private unsafe static extern int sciHasFigures();
+        //=============================================================================
+        /// <summary>
+        ///  get last error code
+        /// </summary>
+        /// <returns>last error code</returns>
+        [DllImport(OUTPUT_STREAM_DLL, CharSet = CharSet.Ansi)]
+        public unsafe static extern int GetLastErrorCode();
+        //=============================================================================
     }
 }
 //=============================================================================
index 8f775b2..6dbf109 100644 (file)
@@ -20,9 +20,10 @@ namespace example
 {
     class example
     {
+        //=============================================================================
         /*
          * A small example to call scilab from C#
-         * read & write matrix of double and matrix of string
+         * read & write matrix of double, string, boolean, int(32)
          */
         static void example_readwriteMatrixOfDouble(Scilab _objScilab)
         {
@@ -42,6 +43,11 @@ namespace example
             _objScilab.sendScilabJob("disp(\'A =\');");
             _objScilab.sendScilabJob("disp(A);");
             //=============================================================================
+            if (_objScilab.getNamedMatrixType("A") == (int)DotNetScilab.Scilab.ScilabType.sci_matrix)
+            {
+                Console.WriteLine("A is a matrix of double");
+            }
+            //=============================================================================
             _objScilab.sendScilabJob("B = A + 1;");
 
             // get dimensions of a named matrix of double
@@ -68,7 +74,7 @@ namespace example
             _objScilab.sendScilabJob("disp(B);");
             //=============================================================================
         }
-
+        //=============================================================================
         static void example_readwriteMatrixOfString(Scilab _objScilab)
         {
             //=============================================================================
@@ -84,6 +90,11 @@ namespace example
             _objScilab.sendScilabJob("disp(\'string_A =\');");
             _objScilab.sendScilabJob("disp(string_A);");
             //=============================================================================
+            if (_objScilab.getNamedMatrixType("string_A") == (int)DotNetScilab.Scilab.ScilabType.sci_strings)
+            {
+                Console.WriteLine("string_A is a matrix of strings");
+            }
+            //=============================================================================
             _objScilab.sendScilabJob("string_B = convstr(string_A,\'u\');");
 
             // get dimensions of a named matrix of string
@@ -110,16 +121,173 @@ namespace example
             //=============================================================================
         }
         //=============================================================================
+        static void example_readwriteMatrixOfBoolean(Scilab _objScilab)
+        {
+            //=============================================================================
+            Boolean[] bA = new Boolean[] { false, true, false,
+                                           true, false, true};
+            int mbA = 2, nbA = 3;
+
+            // Write a matrix of string named in scilab
+            _objScilab.setNamedMatrixOfBoolean("boolean_A", mbA, nbA, bA);
+
+            // display matrix of string by scilab
+            _objScilab.sendScilabJob("disp(\'boolean_A =\');");
+            _objScilab.sendScilabJob("disp(boolean_A);");
+            //=============================================================================
+            // check if av
+            if (_objScilab.existNamedVariable("boolean_A") == true)
+            {
+                Console.WriteLine("boolean_A exists in scilab");
+            }
+
+            if (_objScilab.existNamedVariable("boolean_B") == false)
+            {
+                Console.WriteLine("boolean_B does not exist in scilab");
+            }
+            //=============================================================================
+            if (_objScilab.getNamedMatrixType("boolean_A") == (int)DotNetScilab.Scilab.ScilabType.sci_boolean)
+            {
+                Console.WriteLine("boolean_A is a matrix of boolean");
+            }
+            //=============================================================================
+            _objScilab.sendScilabJob("boolean_B = ~boolean_A;");
+            // get dimensions of a named matrix of boolean
+            int[] DimbB = _objScilab.getNamedMatrixOfBooleanDimensions("boolean_B");
+
+            // get named matrix of boolean
+            Boolean[] bB = _objScilab.getNamedMatrixOfBoolean("boolean_B");
+
+            Console.WriteLine("");
+            Console.WriteLine("(C#) bB =");
+            for (int i = 0; i < DimbB[0]; i++)
+            {
+                for (int j = 0; j < DimbB[1]; j++)
+                {
+                    Console.Write(bB[j * DimbB[0] + i] + " ");
+                }
+
+                Console.WriteLine("");
+            }
+
+            // display matrix of string by scilab
+            _objScilab.sendScilabJob("disp(\'boolean_B =\');");
+            _objScilab.sendScilabJob("disp(boolean_B);");
+            //=============================================================================
+        }
+        //=============================================================================
+        static void example_doplot3d(Scilab _objScilab)
+        {
+            _objScilab.sendScilabJob("plot3d()");
+            while (_objScilab.HaveAGraph())
+            {
+                _objScilab.doEvent();
+            }
+        }
+        //=============================================================================
+        static void example_readwriteMatrixOfInt(Scilab _objScilab)
+        {
+            //=============================================================================
+            int[] A = new int[] { 1, 2, 3, 4, 5, 6 };
+            int mA = 2, nA = 3;
+
+            // Write a matrix of double named in scilab
+            _objScilab.setNamedMatrixOfInt("int32_A", mA, nA, A);
+
+            // display matrix of double by scilab
+            _objScilab.sendScilabJob("disp(\'int32_A =\');");
+            _objScilab.sendScilabJob("disp(int32_A);");
+            //=============================================================================
+            if (_objScilab.getNamedMatrixType("int32_A") == (int)DotNetScilab.Scilab.ScilabType.sci_ints)
+            {
+                Console.WriteLine("int32_A is a matrix of int(32)");
+            }
+            //=============================================================================
+            _objScilab.sendScilabJob("int32_B = int32_A + 1;");
+
+            // get dimensions of a named matrix of double
+            int[] DimB = _objScilab.getNamedMatrixOfDoubleDimensions("int32_B");
+
+            // get named matrix of double
+            int[] B = _objScilab.getNamedMatrixOfInt("int32_B");
+
+            // display matrix of double from C#
+            Console.WriteLine("");
+            Console.WriteLine("(C#) int32_B =");
+            for (int i = 0; i < DimB[0]; i++)
+            {
+                for (int j = 0; j < DimB[1]; j++)
+                {
+                    Console.Write(B[j * DimB[0] + i] + " ");
+                }
+
+                Console.WriteLine("");
+            }
+
+            // display matrix of double by scilab
+            _objScilab.sendScilabJob("disp(\'int32_B =\');");
+            _objScilab.sendScilabJob("disp(int32_B);");
+            //=============================================================================
+        }
+        //=============================================================================
+        static void example_readwriteComplexMatrixOfDouble(Scilab _objScilab)
+        {
+            //=============================================================================
+            double[] realPartA = new double[] { 1, 2, 3, 4, 5, 6 };
+            double[] imagPartA = new double[] { 6, 5, 4, 3, 2, 1 };
+            int mA = 2, nA = 3;
+
+            // Write a matrix of double named in scilab
+            _objScilab.setNamedMatrixOfComplexDouble("cplx_A", mA, nA, realPartA, imagPartA);
+
+            // display matrix of double by scilab
+            _objScilab.sendScilabJob("disp(\'cplx_A =\');");
+            _objScilab.sendScilabJob("disp(cplx_A);");
+            //=============================================================================
+            _objScilab.sendScilabJob("cplx_B = cplx_A * 2;");
+
+            // get dimensions of a named matrix of double
+            int[] DimB = _objScilab.getNamedMatrixOfComplexDoubleDimensions("cplx_B");
+
+            // get named matrix of double
+            double[] realPartB = _objScilab.getNamedMatrixOfComplexDoubleRealPart("cplx_B");
+            double[] imagPartB = _objScilab.getNamedMatrixOfComplexDoubleImagPart("cplx_B");
+
+            // display matrix of double from C#
+            Console.WriteLine("");
+            Console.WriteLine("(C#) cplx_B =");
+            for (int i = 0; i < DimB[0]; i++)
+            {
+                for (int j = 0; j < DimB[1]; j++)
+                {
+                    Console.Write(realPartB[j * DimB[0] + i] + " + i *" + imagPartB[j * DimB[0] + i] + " ");
+                }
+
+                Console.WriteLine("");
+            }
+
+            // display matrix of double by scilab
+            _objScilab.sendScilabJob("disp(\'cplx_B =\');");
+            _objScilab.sendScilabJob("disp(cplx_B);");
+            //=============================================================================
+        }
+        //=============================================================================
         static void Main(string[] args)
         {
-            // start scilab engine
-            Scilab m_oSCilab = new Scilab();
+            // start scilab engine with graphics
+            Scilab m_oSCilab = new Scilab(true);
 
             example_readwriteMatrixOfDouble(m_oSCilab);
+
             example_readwriteMatrixOfString(m_oSCilab);
 
-            // close scilab engine
-            m_oSCilab.finish();
+            example_readwriteMatrixOfBoolean(m_oSCilab);
+
+            example_readwriteMatrixOfInt(m_oSCilab);
+
+            example_readwriteComplexMatrixOfDouble(m_oSCilab);
+
+            example_doplot3d(m_oSCilab);
         }
         //=============================================================================
     }