Integer reading (Scilab gateway)¶

How to read matrix of integer in a list.

Calling Sequence¶

Input argument profile:

Signed integer :

SciErr getMatrixOfInteger8InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char** _pcData)

SciErr getMatrixOfInteger16InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short** _psData)

SciErr getMatrixOfInteger32InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int** _piData)

Unsigned integer :

SciErr getMatrixOfUnsignedInteger8InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned char** _pucData)

SciErr getMatrixOfUnsignedInteger16InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned short** _pusData)

SciErr getMatrixOfUnsignedInteger32InList(void* _pvCtx, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned int** _puiData)

Named variable profile:

Signed integer :

SciErr readMatrixOfIntger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, char* _pcData)

SciErr readMatrixOfIntger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, short* _psData)

SciErr readMatrixOfIntger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, int* _piData)

Unsigned integer :

SciErr readMatrixOfUnsignedInteger8InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned char* _pucData)

SciErr readMatrixOfUnsignedInteger16InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned short* _pusData)

SciErr readMatrixOfUnsignedInteger32InNamedList(void* _pvCtx, const char* _pstName, int* _piParent, int _iItemPos, int* _piRows, int* _piCols, unsigned int* _puiData)

Arguments¶

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

: :_piParent Address of the parent of the new item. : :_pstName Name of the variable for “named” functions. : :_iItemPos Position of the new item in the list. : :_piRows Return number of rows of the variable. : :_piCols Return number of columns of the variable. : :_pcData, _pucData, _psData, _pusData, _piData, _puiData Return

address of data array (size: _iRows * _iCols).

: :SciErr Error structure where is stored errors messages history and: first error number.

:

Description¶

This help describes how to read matrix of integer in a list.

Gateway Source¶

#include "api_scilab.h"

static int iTab = 0;
void insert_indent(void)
{
    int i = 0;
    for(i = 0 ; i < iTab ; i++)
    {
            sciprint("\t");
    }
}

int get_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_list_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_double_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_poly_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_boolean_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_sparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_bsparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_integer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_string_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);
int get_pointer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos);

int common_read(char *fname,unsigned long fname_len)
{
    SciErr sciErr;
    int iItem       = 0;
    int iRet        = 0;
    int *piAddr     = NULL;

    CheckInputArgument(pvApiCtx, 1, 1);

    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    get_info(1, NULL, piAddr, 0);
    AssignOutputVariable(1) = 0;
    return 0;
}

int get_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRet    = 0;
    int iType   = 0;

    sciErr = getVarType(pvApiCtx, _piAddr, &iType);
    switch(iType)
    {
    case sci_matrix :
            iRet = get_double_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_poly :
            iRet = get_poly_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_boolean :
            iRet = get_boolean_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_sparse :
            iRet = get_sparse_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_boolean_sparse :
            iRet = get_bsparse_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_ints :
            iRet = get_integer_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_strings :
            iRet = get_string_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_list :
            insert_indent();
            sciprint("List ");
            iRet = get_list_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_tlist :
            insert_indent();
            sciprint("TList ");
            iRet = get_list_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_mlist :
            insert_indent();
            sciprint("MList ");
            iRet = get_list_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    case sci_pointer :
            iRet = get_pointer_info(_iRhs, _piParent, _piAddr, _iItemPos);
            break;
    default :
            insert_indent();
            sciprint("Unknown type\n");
            return 1;
    }
    return iRet;
}

int get_list_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int i;
    int iRet        = 0;
    int iItem       = 0;
    int* piChild    = NULL;

    sciErr = getListItemNumber(pvApiCtx, _piAddr, &iItem);
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    sciprint("(%d)\n", iItem);
    for(i = 0 ; i < iItem ; i++)
    {
            sciErr = getListItemAddress(pvApiCtx, _piAddr, i + 1, &piChild);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            iTab++;
            iRet = get_info(_iRhs, _piAddr, piChild, i + 1);
            iTab--;
    }
    return 0;;
}

int get_double_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows           = 0;
    int iCols           = 0;
    double* pdblReal    = NULL;
    double* pdblImg     = NULL;

    if(_iItemPos == 0)
    {//not in list
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfDouble(pvApiCtx, _piAddr, &iRows, &iCols, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getMatrixOfDouble(pvApiCtx, _piAddr, &iRows, &iCols, &pdblReal);
            }
    }
    else
    {
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfDoubleInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getMatrixOfDoubleInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pdblReal);
            }
    }

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

    insert_indent();
    sciprint("Double (%d x %d)\n", iRows, iCols);
    return 0;;
}

int get_poly_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int i;
    int iLen            = 0;
    int iRows           = 0;
    int iCols           = 0;
    char pstVar[16];
    int* piCoeff        = NULL;
    double** pdblReal   = NULL;
    double** pdblImg    = NULL;

    sciErr = getPolyVariableName(pvApiCtx, _piAddr, pstVar, &iLen);
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    if(_iItemPos == 0)
    {//not in list
            sciErr = getMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piCoeff     = (int*)malloc(sizeof(int) * iRows * iCols);
            sciErr = getMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, piCoeff, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pdblReal    = (double**)malloc(sizeof(double*) * iRows * iCols);
            pdblImg     = (double**)malloc(sizeof(double*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pdblReal[i] = (double*)malloc(sizeof(double) * piCoeff[i]);
                    pdblImg[i]  = (double*)malloc(sizeof(double) * piCoeff[i]);
            }

            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
                    if(sciErr.iErr)
                    {
                            printError(&sciErr, 0);
                            return 0;
                    }
            }
            else
            {
                    sciErr = getMatrixOfPoly(pvApiCtx, _piAddr, &iRows, &iCols, piCoeff, pdblReal);
                    if(sciErr.iErr)
                    {
                            printError(&sciErr, 0);
                            return 0;
                    }
            }
    }
    else
    {
            sciErr = getMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piCoeff = (int*)malloc(sizeof(int) * iRows * iCols);

            sciErr = getMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pdblReal    = (double**)malloc(sizeof(double*) * iRows * iCols);
            pdblImg     = (double**)malloc(sizeof(double*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pdblReal[i] = (double*)malloc(sizeof(double) * piCoeff[i]);
                    pdblImg[i]  = (double*)malloc(sizeof(double) * piCoeff[i]);
            }

            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal, pdblImg);
            }
            else
            {
                    sciErr = getMatrixOfPolyInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piCoeff, pdblReal);
            }
    }

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

    insert_indent();
    sciprint("Poly  (%d x %d), varname : \'%s\'\n", iRows, iCols, pstVar);

    for(i = 0 ; i < iRows * iCols ; i++)
    {
            free(pdblReal[i]);
            free(pdblImg[i]);
    }

    free(pdblReal);
    free(pdblImg);
    free(piCoeff);
    return 0;;
}
int get_boolean_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows       = 0;
    int iCols       = 0;
    int* piBool     = NULL;

    if(_iItemPos == 0)
    {
            sciErr = getMatrixOfBoolean(pvApiCtx, _piAddr, &iRows, &iCols, &piBool);
    }
    else
    {
            sciErr = getMatrixOfBooleanInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &piBool);
    }

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

    insert_indent();
    sciprint("Boolean (%d x %d)\n", iRows, iCols);
    return 0;
}
int get_sparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows           = 0;
    int iCols           = 0;
    int iItem           = 0;
    int* piNbRow        = NULL;
    int* piColPos       = NULL;
    double* pdblReal    = NULL;
    double* pdblImg     = NULL;

    if(_iItemPos == 0)
    {//Not in list
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexSparseMatrix(pvApiCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getSparseMatrix(pvApiCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal);
            }
    }
    else
    {
            if(isVarComplex(pvApiCtx, _piAddr))
            {
                    sciErr = getComplexSparseMatrixInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal, &pdblImg);
            }
            else
            {
                    sciErr = getSparseMatrixInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos, &pdblReal);
            }
    }

    insert_indent();
    sciprint("Sparse (%d x %d), Item(s) : %d \n", iRows, iCols, iItem);
    return 0;;
}

int get_bsparse_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iRows       = 0;
    int iCols       = 0;
    int iItem       = 0;
    int* piNbRow    = NULL;
    int* piColPos   = NULL;

    if(_iItemPos == 0)
    {//Not in list
            sciErr = getBooleanSparseMatrix(pvApiCtx, _piAddr, &iRows, &iCols, &iItem, &piNbRow, &piColPos);
    }
    else
    {
            sciErr = getBooleanSparseMatrixInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &iItem, &piNbRow, &piColPos);
    }

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

    insert_indent();
    sciprint("Boolean Sparse (%d x %d), Item(s) : %d \n", iRows, iCols, iItem);
    return 0;;
}
int get_integer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int iPrec               = 0;
    int iRows               = 0;
    int iCols               = 0;
    char* pcData            = NULL;
    short* psData           = NULL;
    int* piData             = NULL;
    unsigned char* pucData  = NULL;
    unsigned short* pusData = NULL;
    unsigned int* puiData   = NULL;

    if(_iItemPos == 0)
    {//Not in list
            sciErr = getMatrixOfIntegerPrecision(pvApiCtx, _piAddr, &iPrec);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            switch(iPrec)
            {
            case SCI_INT8 :
                    sciErr = getMatrixOfInteger8(pvApiCtx, _piAddr, &iRows, &iCols, &pcData);
                    break;
            case SCI_INT16 :
                    sciErr = getMatrixOfInteger16(pvApiCtx, _piAddr, &iRows, &iCols, &psData);
                    break;
            case SCI_INT32 :
                    sciErr = getMatrixOfInteger32(pvApiCtx, _piAddr, &iRows, &iCols, &piData);
                    break;
            case SCI_UINT8 :
                    sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, _piAddr, &iRows, &iCols, &pucData);
                    break;
            case SCI_UINT16 :
                    sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, _piAddr, &iRows, &iCols, &pusData);
                    break;
            case SCI_UINT32 :
                    sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, _piAddr, &iRows, &iCols, &puiData);
                    break;
            default :
                    return 1;
            }
    }
    else
    {
            sciErr = getMatrixOfIntegerPrecision(pvApiCtx, _piAddr, &iPrec);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            switch(iPrec)
            {
            case SCI_INT8 :
                    sciErr = getMatrixOfInteger8InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pcData);
                    break;
            case SCI_INT16 :
                    sciErr = getMatrixOfInteger16InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &psData);
                    break;
            case SCI_INT32 :
                    sciErr = getMatrixOfInteger32InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &piData);
                    break;
            case SCI_UINT8 :
                    sciErr = getMatrixOfUnsignedInteger8InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pucData);
                    break;
            case SCI_UINT16 :
                    sciErr = getMatrixOfUnsignedInteger16InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &pusData);
                    break;
            case SCI_UINT32 :
                    sciErr = getMatrixOfUnsignedInteger32InList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, &puiData);
                    break;
            default :
                    return 1;
            }
    }

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

    insert_indent();

    if(iPrec > 10)
    {
            sciprint("Unsigned ");
    }

    sciprint("Integer %d bits (%d x %d)\n", (iPrec % 10) * 8, iRows, iCols);
    return 0;;
}
int get_string_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    int i;
    int iRows       = 0;
    int iCols       = 0;
    int* piLen      = NULL;
    char **pstData  = NULL;

    if(_iItemPos == 0)
    {//Not in list
            sciErr = getMatrixOfString(pvApiCtx, _piAddr, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piLen = (int*)malloc(sizeof(int) * iRows * iCols);
            sciErr = getMatrixOfString(pvApiCtx, _piAddr, &iRows, &iCols, piLen, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pstData = (char**)malloc(sizeof(char*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
            }

            sciErr = getMatrixOfString(pvApiCtx, _piAddr, &iRows, &iCols, piLen, pstData);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }
    }
    else
    {
            sciErr = getMatrixOfStringInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, NULL, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            piLen = (int*)malloc(sizeof(int) * iRows * iCols);

            sciErr = getMatrixOfStringInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piLen, NULL);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }

            pstData = (char**)malloc(sizeof(char*) * iRows * iCols);

            for(i = 0 ; i < iRows * iCols ; i++)
            {
                    pstData[i] = (char*)malloc(sizeof(char) * (piLen[i] + 1));//+ 1 for null termination
            }

            sciErr = getMatrixOfStringInList(pvApiCtx, _piParent, _iItemPos, &iRows, &iCols, piLen, pstData);
            if(sciErr.iErr)
            {
                    printError(&sciErr, 0);
                    return 0;
            }
    }
    if(sciErr.iErr)
    {
            printError(&sciErr, 0);
            return 0;
    }

    insert_indent();
    sciprint("Strings (%d x %d)\n", iRows, iCols);
    return 0;;
}
int get_pointer_info(int _iRhs, int* _piParent, int *_piAddr, int _iItemPos)
{
    SciErr sciErr;
    void* pvPtr     = NULL;

    if(_iItemPos == 0)
    {
            sciErr = getPointer(pvApiCtx, _piAddr, &pvPtr);
    }
    else
    {
            sciErr = getPointerInList(pvApiCtx, _piParent, _iItemPos, &pvPtr);
    }

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

    insert_indent();
    sciprint("Pointer : 0x%08X\n", pvPtr);
    return 0;
}

Scilab test script¶

function read_all()
d = [1,2,3;4,5,6;7,8,9];common_read(d);
s=`poly`_(0,"x");p=1+s+2*s^2;p = [(p * 2),(p * s + 3);(p * 2 * s ** 2 - 6),(12 - 4 * p * (- s) ** 2)];common_read(p);
b = [%t,%f;%t,%f;%f,%t];common_read(b);
sp=`sparse`_([2,-1,0,0,0;-1,2,-1,0,0;0,-1,2,-1,0;0,0,-1,2,-1;0,0,0,-1,2]);common_read(sp);
bsp=`sparse`_([1,2;4,5;3,10],[%t,%t,%t]);common_read(bsp);
i8 = `int8`_([1,2,3]);common_read(i8);
ui32 = `uint32`_([3;2;1]);common_read(ui32);
str = ["may", "the", "puffin"; "be", "with","you"];common_read(str);
if `with_module`_('umfpack') then
    Cp = `taucs_chfact`_(sp);
    l = `list`_(`list`_(d, p, `list`_(b, sp)), `list`_(i8, bsp), `list`_(ui32, str), Cp);
else
    l = `list`_(`list`_(d, p, `list`_(b, sp)), `list`_(i8, bsp), `list`_(ui32, str));
end
common_read(l)
endfunction
read_all;

Integer reading (Scilab gateway)¶

Calling Sequence¶

Arguments¶

Description¶

Gateway Source¶

Scilab test script¶

Table Of Contents

This Page

Navigation

Integer reading (Scilab gateway)¶

Calling Sequence¶

Arguments¶

Description¶

Gateway Source¶

Scilab test script¶

Table Of Contents

This Page

Quick search

Navigation