Scilab Website | Contribute with GitLab | Mailing list archives | ATOMS toolboxes
Scilab Online Help
5.4.1 - Português

Change language to:
English - Français - 日本語 - Русский

Please note that the recommended version of Scilab is 2024.0.0. This page might be outdated.
However, this page did not exist in the previous stable version.

Ajuda Scilab >> API Scilab > Low level functions > Integer reading (Scilab gateway)

Integer reading (Scilab gateway)

How to read matrices of integer in a gateway.

Calling Sequence

Input argument profile:

Signed integer :

SciErr getMatrixOfInteger8(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, char** _pcData8)
SciErr getMatrixOfInteger16(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, short** _psData16)
SciErr getMatrixOfInteger32(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, int** _piData32)

Unsigned integer :

SciErr getMatrixOfUnsignedInteger8(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned char** _pucData8)
SciErr getMatrixOfUnsignedInteger16(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned short** _pusData16)
SciErr getMatrixOfUnsignedInteger32(void* _pvCtx, int* _piAddress, int* _piRows, int* _piCols, unsigned int** _puiData32)

Named variable profile:

Signed integer :

SciErr readNamedMatrixOfInteger8(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, char* _pcData8)
SciErr readNamedMatrixOfInteger16(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, short* _psData16)
SciErr readNamedMatrixOfInteger32(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, int* _piData32)

Unsigned integer :

SciErr readNamedMatrixOfUnsignedInteger8(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned char* _pucData8)
SciErr readNamedMatrixOfUnsignedInteger16(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned short* _pusData16)
SciErr readNamedMatrixOfUnsignedInteger32(void* _pvCtx, const char* _pstName, int* _piRows, int* _piCols, unsigned int* _puiData32)

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.

_pcData8, _pucData8, _psData16, _pusData16, _piData32, _puiData32

Returns address of array ( size: _piRows * _piCols). For "Named" function, _pcData must be allocated before calling function.

SciErr

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

Description

This help describes how matrices of integer can be handled through the Scilab API.

Gateway Source

#include "api_scilab.h"
void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn);

int read_integer(char *fname,unsigned long fname_len)
{
	SciErr sciErr;
	//output variable info
	int iRows8					= 0;
	int iCols8					= 0;
	int iRows16					= 0;
	int iCols16					= 0;
	int iRows32					= 0;
	int iCols32					= 0;
	int iRowsu8					= 0;
	int iColsu8					= 0;
	int iRowsu16				= 0;
	int iColsu16				= 0;
	int iRowsu32				= 0;
	int iColsu32				= 0;
	int iPrec					= 0;
	int* piAddr8				= NULL;
	int* piAddr16				= NULL;
	int* piAddr32				= NULL;
	int* piAddru8				= NULL;
	int* piAddru16				= NULL;
	int* piAddru32				= NULL;
	char* pcData				= NULL;
	short* psData				= NULL;
	int* piData					= NULL;
	unsigned char* pucData		= NULL;
	unsigned short* pusData		= NULL;
	unsigned int* puiData		= NULL;
	char* pcDataOut				= NULL;
	short* psDataOut			= NULL;
	int* piDataOut				= NULL;
	unsigned char* pucDataOut	= NULL;
	unsigned short* pusDataOut	= NULL;
	unsigned int* puiDataOut	= NULL;

	//check input/ouput arguments count
    CheckInputArgument(pvApiCtx, 6, 6);
    CheckOutputArgument(pvApiCtx, 6, 6);

	//get varialbe address
	sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr8);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

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

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

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

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

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

	//check variable precision
	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr8, &iPrec);
	if(sciErr.iErr || iPrec != SCI_INT8)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//check variable precision
	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru8, &iPrec);
	if(sciErr.iErr || iPrec != SCI_UINT8)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//check variable precision
	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr16, &iPrec);
	if(sciErr.iErr || iPrec != SCI_INT16)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//check variable precision
	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru16, &iPrec);
	if(sciErr.iErr || iPrec != SCI_UINT16)
	{
		printError(&sciErr, 0);
		return 0;
	}
	//check variable precision
	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddr32, &iPrec);
	if(sciErr.iErr || iPrec != SCI_INT32)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//check variable precision
	sciErr = getMatrixOfIntegerPrecision(pvApiCtx, piAddru32, &iPrec);
	if(sciErr.iErr || iPrec != SCI_UINT32)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//retrieve dimensions and data
	sciErr = getMatrixOfInteger8(pvApiCtx, piAddr8, &iRows8, &iCols8, &pcData);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//retrieve dimensions and data
	sciErr = getMatrixOfUnsignedInteger8(pvApiCtx, piAddru8, &iRowsu8, &iColsu8, &pucData);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//retrieve dimensions and data
	sciErr = getMatrixOfInteger16(pvApiCtx, piAddr16, &iRows16, &iCols16, &psData);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//retrieve dimensions and data
	sciErr = getMatrixOfUnsignedInteger16(pvApiCtx, piAddru16, &iRowsu16, &iColsu16, &pusData);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//retrieve dimensions and data
	sciErr = getMatrixOfInteger32(pvApiCtx, piAddr32, &iRows32, &iCols32, &piData);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//retrieve dimensions and data
	sciErr = getMatrixOfUnsignedInteger32(pvApiCtx, piAddru32, &iRowsu32, &iColsu32, &puiData);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//alloc and fill new variable
	pcDataOut   = (char*)create_output(2, 1, iRows8, iCols8, (void*)pcData);
	pucDataOut  = (unsigned char*)create_output(4, 1, iRowsu8, iColsu8, (void*)pucData);
	psDataOut   = (short*)create_output(8, 2, iRows16, iCols16, (void*)psData);
	pusDataOut  = (unsigned short*)create_output(16, 2, iRowsu16, iColsu16, (void*)pusData);
	piDataOut   = (int*)create_output(32, 4, iRows32, iCols32, (void*)piData);
	puiDataOut  = (unsigned int*)create_output(64, 4, iRowsu32, iColsu32, (void*)puiData);

	//create new variable
	sciErr = createMatrixOfInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 1, iRows8, iCols8, pcDataOut);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//create new variable
	sciErr = createMatrixOfUnsignedInteger8(pvApiCtx, nbInputArgument(pvApiCtx) + 2, iRowsu8, iColsu8, pucDataOut);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//create new variable
	sciErr = createMatrixOfInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 3, iRows16, iCols16, psDataOut);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//create new variable
	sciErr = createMatrixOfUnsignedInteger16(pvApiCtx, nbInputArgument(pvApiCtx) + 4, iRowsu16, iColsu16, pusDataOut);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//create new variable
	sciErr = createMatrixOfInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 5, iRows32, iCols32, piDataOut);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//create new variable
	sciErr = createMatrixOfUnsignedInteger32(pvApiCtx, nbInputArgument(pvApiCtx) + 6, iRowsu32, iColsu32, puiDataOut);
	if(sciErr.iErr)
	{
		printError(&sciErr, 0);
		return 0;
	}

	//assign allocated variables to Lhs position
	AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
	AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
	AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
	AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
	AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
	AssignOutputVariable(pvApiCtx, 6) = nbInputArgument(pvApiCtx) + 6;
	return 0;
}

void* create_output(int _iCoeff, int _iSize, int _iRows, int _iCols, void* _pvDataIn)
{
	int i = 0;
	void* pvDataOut = (void*)malloc(_iSize * _iRows * _iCols);
	for(i = 0 ; i < _iRows * _iCols ; i++)
	{
		int iVal = 0;
		memcpy(&iVal, (char*)_pvDataIn + i * _iSize, _iSize);
		iVal *= _iCoeff;
		memcpy((char*)pvDataOut + i * _iSize, &iVal, _iSize);
	}
	return pvDataOut;
}

Scilab test script

a8  = int8([    1   -2  3   -4  5; ..
                -6  7   -8  9   -10; ..
                11  -12 13  -14 15]);

au8 = uint8([   1   2   3   4   5; ..
                6   7   8   9   10; ..
                11  12  13  14  15]);

a16  = int16([  1   -2  3   -4  5; ..
                -6  7   -8  9   -10; ..
                11  -12 13  -14 15]);

au16 = uint16([ 1   2   3   4   5; ..
                6   7   8   9   10; ..
                11  12  13  14  15]);

a32 = int32([   1   -2  3   -4  5; ..
                -6  7   -8  9   -10; ..
                11  -12 13  -14 15]);

au32 = uint32([ 1   2   3   4   5; ..
                6   7   8   9   10; ..
                11  12  13  14  15]);

[c8, cu8, c16, cu16, c32, cu32] = read_integer(a8, au8, a16, au16, a32, au32);

if or(c8 <> a8 * 2) then error("failed"), end
if or(cu8 <> au8 * 4) then error("failed"), end
if or(c16 <> a16 * 8) then error("failed"), end
if or(cu16 <> au16 * 16) then error("failed"), end
if or(c32 <> a32 * 32) then error("failed"), end
if or(cu32 <> au32 * 64) then error("failed"), end
Report an issue
<< Integer Precision (Scilab gateway) Low level functions Integer writing (Scilab gateway) >>

Copyright (c) 2022-2023 (Dassault Systèmes)
Copyright (c) 2017-2022 (ESI Group)
Copyright (c) 2011-2017 (Scilab Enterprises)
Copyright (c) 1989-2012 (INRIA)
Copyright (c) 1989-2007 (ENPC)
with contributors
Last updated:
Tue Apr 02 17:37:07 CEST 2013