Double reading (Scilab gateway)

How to read matrices of double in a gateway.

Calling Sequence

Input argument profile:

SciErr getMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal)

SciErr getComplexMatrixOfDouble(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, double** _pdblReal, double** _pdblImg)

Named variable profile:

SciErr readNamedMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal)

SciErr readNamedComplexMatrixOfDouble(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, double* _pdblReal, double* _pdblImg)

Arguments

:_pvCtx Scilab environment pointer, pass in “pvApiCtx” provided by

api_scilab.h

: :_piAddress Address of the Scilab variable. : :_pstName Name of the variable for “named” functions. : :_piRows Return number of rows. : :_piCols Return number of columns. : :_pdblReal Return address of real data array (size: _iCols *

_iRows). For “Named” function, _pdblReal must be allocated before calling function.

: :_pdblImg Return address of imaginary data array (size: _iCols *

_iRows). For “Named” function, _pdblImg must be allocated before calling function.

: :SciErr Error structure where is stored errors messages history and

first error number.

:

Description

This help describes how matrix of doubles can be handled through the Scilab API.

Gateway Source

#include "api_scilab.h"
int read_double(char *fname,unsigned long fname_len)
{
    SciErr sciErr;
    int i;
    //first variable info : real matrix of double
    int iType                       = 0;
    int iRows                       = 0;
    int iCols                       = 0;
    int iComplex            = 0;
    int *piAddr                     = NULL;
    double* pdblReal        = NULL;
    double* pdblImg         = NULL;

    //check input and output arguments
    CheckInputArgument(pvApiCtx, 1, 1);
    CheckOutputArgument(pvApiCtx, 1, 1);

    /************************
    *    First variable    *
    ************************/

    //get variable address of the first input argument
    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    //check type
    sciErr = getVarType(pvApiCtx, piAddr, &iType);
    if(sciErr.iErr || iType != sci_matrix)
    {
            printError(&sciErr, 0);
            return 0;
    }

    //get complexity
    iComplex        = isVarComplex(pvApiCtx, piAddr);

    //check complexity
    if(iComplex)
    {
            //get size and data from Scilab memory
            sciErr = getComplexMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
    }
    else
    {
            //get size and data from Scilab memory
            sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &iRows, &iCols, &pdblReal);
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    //Do something with data
    //if variable is complex, switch real part and imaginary part otherwise multiply by -1
    if(iComplex)
    {
            sciErr = createComplexMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblImg, pdblReal);
    }
    else
    {
            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pdblReal[i] = pdblReal[i] * -1;
            }
            sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument + 1, iRows, iCols, pdblReal);
    }

    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    AssignOutputVariable(1) = nbInputArgument + 1;
    return 0;
}

Scilab test script

a = [   0 1 2 3; ..
        4 5 6 7; ..
        8 9 10 11];
b = [   23*%i,      1+22*%i,    2+21*%i,    3+20*%i,    4+19*%i,    5+18*%i; ..
        6+17*%i,    7+16*%i,    8+15*%i,    9+14*%i,     10+13*%i,  11+12*%i; ..
        12+11*%i,   13+10*%i,   14+9*%i,    15+8*%i,    16+7*%i,    17+6*%i; ..
        18+5*%i,    19+4*%i,    20+3*%i,    21+2*%i,    22+1*%i,    23];

a2 = read_double(a);
b2 = read_double(b);

if `or`_(a2 <> a * -1) then `error`_("failed"), end
if `or`_(b2 <> (`imag`_(b) + `real`_(b) * %i)) then `error`_("failed"), end