scilab: test *matrix, size) array typemaps
This commit is contained in:
Simon Marchetto
parent
c4381e8d57
commit
a4979d8d7e
3 changed files with 149 additions and 96 deletions
|
|
@ -3,62 +3,66 @@
|
|||
exec("swigtest.start", -1);
|
||||
|
||||
// test matrix passed as output argument from fonction
|
||||
function test_out_matrix(value_type, expected_out_matrix)
|
||||
func_name = msprintf("out_%s_matrix_func", value_type);
|
||||
function test_out_matrix(func, value_type, expected_out_matrix)
|
||||
func_name = msprintf("out_%s_%s", value_type, func);
|
||||
cmd = msprintf("out_matrix = %s();", func_name);
|
||||
ierr = execstr(cmd, "errcatch");
|
||||
if ierr <> 0 then
|
||||
swigtesterror(msprintf("Error %d in %s", ierr, func_name));
|
||||
end
|
||||
if ~isdef('out_matrix') | ~isequal(out_matrix, expected_out_matrix) then
|
||||
swigtesterror(msprintf("Wrong value returned from %s()", func_name));
|
||||
end
|
||||
checkequal(out_matrix, expected_out_matrix, func_name);
|
||||
endfunction
|
||||
|
||||
// test matrix passed as input argument of fonction
|
||||
function test_in_matrix(value_type, in_matrix, expected_in_value)
|
||||
func_name = msprintf("in_%s_matrix_func", value_type);
|
||||
function test_in_matrix(func, value_type, in_matrix, expected_in_value)
|
||||
func_name = msprintf("in_%s_%s", value_type, func);
|
||||
cmd = msprintf("in_value = %s(in_matrix);", func_name);
|
||||
ierr = execstr(cmd, "errcatch");
|
||||
if ierr <> 0 then
|
||||
swigtesterror(msprintf("Error %d in %s", ierr, func_name));
|
||||
end
|
||||
if ~isdef('in_value') | ~isequal(in_value, expected_in_value) then
|
||||
swigtesterror(msprintf("Wrong value returned from %s()", func_name));
|
||||
end
|
||||
checkequal(in_value, expected_in_value, func_name);
|
||||
endfunction
|
||||
|
||||
// test matrixes passed as input and output arguments of fonction
|
||||
function test_inout_matrix(value_type, inout_matrix, expected_inout_matrix)
|
||||
func_name = msprintf("inout_%s_matrix_func", value_type);
|
||||
function test_inout_matrix(func, value_type, inout_matrix, expected_inout_matrix)
|
||||
func_name = msprintf("inout_%s_%s", value_type, func);
|
||||
cmd = msprintf("inout_matrix = %s(inout_matrix);", func_name);
|
||||
ierr = execstr(cmd, "errcatch");
|
||||
if ierr <> 0 then
|
||||
swigtesterror(msprintf("Error %d in %s", ierr, func_name));
|
||||
end
|
||||
if ~isdef('inout_matrix') | ~isequal(inout_matrix, expected_inout_matrix) then
|
||||
swigtesterror(msprintf("Wrong value returned from %s()", func_name));
|
||||
end
|
||||
checkequal(inout_matrix, expected_inout_matrix, func_name);
|
||||
endfunction
|
||||
|
||||
function test_matrix_typemaps(value_type, matrix, expected_out_matrix, expected_in_value, expected_inout_matrix)
|
||||
test_out_matrix(value_type, expected_out_matrix);
|
||||
test_in_matrix(value_type, matrix, expected_in_value);
|
||||
test_inout_matrix(value_type, matrix, expected_inout_matrix);
|
||||
function test_matrix_typemaps(value_type, ..
|
||||
expected_out_matrix_dims, expected_out_matrix_size, ..
|
||||
expected_in_value, ..
|
||||
expected_inout_matrix_dims, expected_inout_matrix_size)
|
||||
|
||||
test_out_matrix("matrix_dims", value_type, expected_out_matrix_dims);
|
||||
test_out_matrix("matrix_size", value_type, expected_out_matrix_size);
|
||||
matrix_dims = expected_out_matrix_dims;
|
||||
matrix_size = expected_out_matrix_size;
|
||||
test_in_matrix("matrix_dims", value_type, matrix_dims, expected_in_value);
|
||||
test_in_matrix("matrix_size", value_type, matrix_size, expected_in_value);
|
||||
test_inout_matrix("matrix_dims", value_type, matrix_dims, expected_inout_matrix_dims);
|
||||
test_inout_matrix("matrix_size", value_type, matrix_size, expected_inout_matrix_size);
|
||||
endfunction
|
||||
|
||||
|
||||
m = [0. 3.; 1. 4.; 2. 5.];
|
||||
test_matrix_typemaps("int", m, m, sum(m), m .* m);
|
||||
test_matrix_typemaps("int", int32(m), m, sum(m), m .* m);
|
||||
m = [0 3; 1 4; 2 5];
|
||||
v = [0 1 2 3 4 5];
|
||||
test_matrix_typemaps("int", m, v, sum(m), m .* m, v .* v);
|
||||
test_matrix_typemaps("double", m, v, sum(m), m .* m, v .* v);
|
||||
|
||||
test_matrix_typemaps("double", m, m, sum(m), m .* m);
|
||||
m = ["A" "D"; "B" "E"; "C" "F"];
|
||||
v = ["A" "B" "C" "D" "E" "F"];
|
||||
test_matrix_typemaps("charptr", m, v, strcat(m), m + m, v + v);
|
||||
|
||||
m = ["A" "D"; "B" "E"; "C" "F"]
|
||||
test_matrix_typemaps("charptr", m, m, strcat(m), m + m);
|
||||
|
||||
m = [%T, %F; %F, %T; %T, %F];
|
||||
test_matrix_typemaps("bool", m, m, %T, ~m);
|
||||
m = [%T %F; %F %T; %T %F];
|
||||
v = [%T %F %T %F %T %F];
|
||||
test_matrix_typemaps("bool", m, v, %T, ~m, ~v);
|
||||
|
||||
|
||||
exec("swigtest.quit", -1);
|
||||
|
|
|
|||
|
|
@ -3,8 +3,10 @@
|
|||
%include matrix.i
|
||||
|
||||
%define %use_matrix_apply(TYPE...)
|
||||
%apply (TYPE *matrixIn, int matrixInRowCount, int matrixInColCount) { (TYPE *inputMatrix, int nbRow, int nbCol) }
|
||||
%apply (TYPE **matrixOut, int *matrixOutRowCount, int *matrixOutColCount) { (TYPE **resultMatrix, int *nbRowRes, int *nbColRes) }
|
||||
%apply (TYPE *matrixIn, int matrixInRowCount, int matrixInColCount) { (TYPE *matrix, int nbRow, int nbCol) }
|
||||
%apply (TYPE **matrixOut, int *matrixOutRowCount, int *matrixOutColCount) { (TYPE **matrixRes, int *nbRowRes, int *nbColRes) }
|
||||
%apply (TYPE *matrixIn, int matrixInSize) { (TYPE *matrix, int size) }
|
||||
%apply (TYPE **matrixOut, int *matrixOutSize) { (TYPE **matrixRes, int *sizeRes) }
|
||||
%enddef
|
||||
|
||||
%use_matrix_apply(int);
|
||||
|
|
@ -14,113 +16,138 @@
|
|||
|
||||
%inline %{
|
||||
|
||||
// int and double matrix functions
|
||||
template<typename T> T in_matrix_func(T *inputMatrix, int nbRow, int nbCol) {
|
||||
/*
|
||||
* (T *matrixIn, int matrixInSize) pattern functions
|
||||
*/
|
||||
|
||||
template<typename T> T in_matrix_size(T *matrix, int size) {
|
||||
T sum = 0;
|
||||
int i;
|
||||
for (i=0; i<nbRow*nbCol; i++)
|
||||
sum += inputMatrix[i];
|
||||
for (i = 0; i < size; i++)
|
||||
sum += matrix[i];
|
||||
return sum;
|
||||
}
|
||||
|
||||
template<typename T> void out_matrix_func(T **resultMatrix, int *nbRowRes, int *nbColRes) {
|
||||
template<typename T> void out_matrix_size(T **matrixRes, int *sizeRes) {
|
||||
int size;
|
||||
int i;
|
||||
*nbRowRes = 3;
|
||||
*nbColRes = 2;
|
||||
size = (*nbRowRes) * (*nbColRes);
|
||||
*resultMatrix = (T*) malloc(size * sizeof(T));
|
||||
for (i=0; i<size; i++)
|
||||
(*resultMatrix)[i] = i;
|
||||
*sizeRes = 6;
|
||||
*matrixRes = (T*) malloc(*sizeRes * sizeof(T));
|
||||
for (i = 0; i < *sizeRes; i++)
|
||||
(*matrixRes)[i] = i;
|
||||
}
|
||||
|
||||
template<typename T> void inout_matrix_func(T *inputMatrix, int nbRow, int nbCol, T **resultMatrix, int *nbRowRes, int *nbColRes) {
|
||||
template<typename T> void inout_matrix_size(T *matrix, int size, T **matrixRes, int *sizeRes) {
|
||||
int i;
|
||||
int size = nbRow * nbCol;
|
||||
*nbRowRes = nbRow;
|
||||
*nbColRes = nbCol;
|
||||
*resultMatrix = (T*) malloc(size * sizeof(T));
|
||||
for (i=0; i<size; i++) {
|
||||
(*resultMatrix)[i] = inputMatrix[i] * inputMatrix[i];
|
||||
*sizeRes = size;
|
||||
*matrixRes = (T*) malloc(size * sizeof(T));
|
||||
for (i = 0; i < size; i++) {
|
||||
(*matrixRes)[i] = matrix[i] * matrix[i];
|
||||
}
|
||||
}
|
||||
|
||||
// char* matrix functions
|
||||
template<> char* in_matrix_func(char **inputMatrix, int nbRow, int nbCol) {
|
||||
char *s = (char *) malloc(nbRow * nbCol * sizeof(char) + 1);
|
||||
/*
|
||||
* (char **matrixIn, int matrixInSize) pattern functions
|
||||
*/
|
||||
|
||||
template<> char* in_matrix_size(char **matrix, int size) {
|
||||
char *s = (char *) calloc(size + 1, sizeof(char));
|
||||
int i;
|
||||
for (i=0; i<nbRow*nbCol; i++)
|
||||
strcat(s, inputMatrix[i]);
|
||||
for (i = 0; i < size; i++)
|
||||
strcat(s, matrix[i]);
|
||||
return s;
|
||||
}
|
||||
|
||||
template<> void out_matrix_func(char ***resultMatrix, int *nbRowRes, int *nbColRes) {
|
||||
int size;
|
||||
template<> void out_matrix_size(char ***matrixRes, int *sizeRes) {
|
||||
char *s;
|
||||
int i;
|
||||
*nbRowRes = 3;
|
||||
*nbColRes = 2;
|
||||
size = (*nbRowRes) * (*nbColRes);
|
||||
*resultMatrix = (char **) malloc(size * sizeof(char *));
|
||||
for (i=0; i<size; i++) {
|
||||
*sizeRes = 6;
|
||||
*matrixRes = (char **) malloc(*sizeRes * sizeof(char *));
|
||||
for (i = 0; i < *sizeRes; i++) {
|
||||
s = (char *) malloc(sizeof(char)+1);
|
||||
sprintf(s, "%c", char(65 + i));
|
||||
(*resultMatrix)[i] = s;
|
||||
(*matrixRes)[i] = s;
|
||||
}
|
||||
}
|
||||
|
||||
template<> void inout_matrix_func(char **inputMatrix, int nbRow, int nbCol, char ***resultMatrix, int *nbRowRes, int *nbColRes) {
|
||||
template<> void inout_matrix_size(char **matrix, int size,
|
||||
char ***matrixRes, int *sizeRes) {
|
||||
int i;
|
||||
char *s;
|
||||
int size = nbRow * nbCol;
|
||||
*nbRowRes = nbRow;
|
||||
*nbColRes = nbCol;
|
||||
*resultMatrix = (char **) malloc(size * sizeof(char* ));
|
||||
for (i=0; i<size; i++) {
|
||||
s = (char *) malloc((2 * strlen(inputMatrix[i]) + 1) * sizeof(char));
|
||||
sprintf(s, "%s%s", inputMatrix[i], inputMatrix[i]);
|
||||
(*resultMatrix)[i] = s;
|
||||
*sizeRes = size;
|
||||
*matrixRes = (char **) malloc(*sizeRes * sizeof(char* ));
|
||||
for (i = 0; i < *sizeRes; i++) {
|
||||
s = (char *) malloc((2 * strlen(matrix[i]) + 1) * sizeof(char));
|
||||
sprintf(s, "%s%s", matrix[i], matrix[i]);
|
||||
(*matrixRes)[i] = s;
|
||||
}
|
||||
}
|
||||
|
||||
// bool matrix functions
|
||||
template<> bool in_matrix_func(bool *inputMatrix, int nbRow, int nbCol) {
|
||||
/*
|
||||
* (bool **matrixIn, int matrixInSize) pattern functions
|
||||
*/
|
||||
|
||||
template<> bool in_matrix_size(bool *matrix, int size) {
|
||||
bool b = true;
|
||||
int i;
|
||||
b = inputMatrix[0];
|
||||
for (i=1; i<nbRow*nbCol; i++)
|
||||
b = b ^ inputMatrix[i];
|
||||
b = matrix[0];
|
||||
for (i = 1; i < size; i++)
|
||||
b = b ^ matrix[i];
|
||||
return b;
|
||||
}
|
||||
|
||||
template<> void out_matrix_func(bool **resultMatrix, int *nbRowRes, int *nbColRes) {
|
||||
int size;
|
||||
template<> void out_matrix_size(bool **matrixRes, int *sizeRes) {
|
||||
int i;
|
||||
*nbRowRes = 3;
|
||||
*nbColRes = 2;
|
||||
size = (*nbRowRes) * (*nbColRes);
|
||||
*resultMatrix = (bool*) malloc(size * sizeof(bool));
|
||||
for (i=0; i<size; i++) {
|
||||
(*resultMatrix)[i] = i % 2 == 0;
|
||||
*sizeRes = 6;
|
||||
*matrixRes = (bool*) malloc(*sizeRes * sizeof(bool));
|
||||
for (i = 0; i < *sizeRes; i++) {
|
||||
(*matrixRes)[i] = i % 2 == 0;
|
||||
}
|
||||
}
|
||||
|
||||
template<> void inout_matrix_func(bool *inputMatrix, int nbRow, int nbCol, bool **resultMatrix, int *nbRowRes, int *nbColRes) {
|
||||
template<> void inout_matrix_size(bool *matrix, int size,
|
||||
bool **matrixRes, int *sizeRes) {
|
||||
int i;
|
||||
int size = nbRow * nbCol;
|
||||
*nbRowRes = nbRow;
|
||||
*nbColRes = nbCol;
|
||||
*resultMatrix = (bool*) malloc(size * sizeof(bool));
|
||||
for (i=0; i<size; i++) {
|
||||
(*resultMatrix)[i] = inputMatrix[i]==1?0:1;
|
||||
*sizeRes = size;
|
||||
*matrixRes = (bool*) malloc(*sizeRes * sizeof(bool));
|
||||
for (i = 0; i < *sizeRes; i++) {
|
||||
(*matrixRes)[i] = matrix[i] == 1 ? 0 : 1;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* (T *matrixIn, int matrixInRowCount, int matrixInColCount) pattern functions
|
||||
*/
|
||||
|
||||
template<typename T> T in_matrix_dims(T *matrix, int nbRow, int nbCol) {
|
||||
return in_matrix_size(matrix, nbRow * nbCol);
|
||||
}
|
||||
|
||||
template<typename T> void out_matrix_dims(T **matrixRes, int *nbRowRes, int *nbColRes) {
|
||||
int size = 0;
|
||||
out_matrix_size(matrixRes, &size);
|
||||
*nbRowRes = 3;
|
||||
*nbColRes = 2;
|
||||
}
|
||||
|
||||
template<typename T> void inout_matrix_dims(T *matrix, int nbRow, int nbCol,
|
||||
T **matrixRes, int *nbRowRes, int *nbColRes) {
|
||||
*nbRowRes = nbRow;
|
||||
*nbColRes = nbCol;
|
||||
int sizeRes = 0;
|
||||
inout_matrix_size(matrix, nbRow * nbCol, matrixRes, &sizeRes);
|
||||
}
|
||||
|
||||
|
||||
%}
|
||||
|
||||
%define %instantiate_matrix_template_functions(NAME, TYPE...)
|
||||
%template(in_ ## NAME ## _matrix_func) in_matrix_func<TYPE>;
|
||||
%template(out_ ## NAME ## _matrix_func) out_matrix_func<TYPE>;
|
||||
%template(inout_ ## NAME ## _matrix_func) inout_matrix_func<TYPE>;
|
||||
%template(in_ ## NAME ## _matrix_dims) in_matrix_dims<TYPE>;
|
||||
%template(out_ ## NAME ## _matrix_dims) out_matrix_dims<TYPE>;
|
||||
%template(inout_ ## NAME ## _matrix_dims) inout_matrix_dims<TYPE>;
|
||||
%template(in_ ## NAME ## _matrix_size) in_matrix_size<TYPE>;
|
||||
%template(out_ ## NAME ## _matrix_size) out_matrix_size<TYPE>;
|
||||
%template(inout_ ## NAME ## _matrix_size) inout_matrix_size<TYPE>;
|
||||
%enddef
|
||||
|
||||
%instantiate_matrix_template_functions(int, int);
|
||||
|
|
|
|||
|
|
@ -29,7 +29,29 @@
|
|||
|
||||
%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (char **matrixIn, int matrixInSize)
|
||||
{
|
||||
if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, 1, &$2, &$1, fname) != SWIG_OK)
|
||||
int rowCount;
|
||||
int colCount;
|
||||
if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$1, fname) == SWIG_OK)
|
||||
{
|
||||
$2 = rowCount * colCount;
|
||||
}
|
||||
else
|
||||
{
|
||||
return SWIG_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
// in (int matrixInSize, char **matrixIn)
|
||||
|
||||
%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (int matrixInSize, char **matrixIn)
|
||||
{
|
||||
int rowCount;
|
||||
int colCount;
|
||||
if (SWIG_SciString_AsCharPtrArrayAndSize(pvApiCtx, $input, &rowCount, &colCount, &$2, fname) == SWIG_OK)
|
||||
{
|
||||
$1 = rowCount * colCount;
|
||||
}
|
||||
else
|
||||
{
|
||||
return SWIG_ERROR;
|
||||
}
|
||||
|
|
@ -138,7 +160,7 @@
|
|||
|
||||
%typemap(argout, noblock=1, fragment="SWIG_SciString_FromCharPtrArrayAndSize") (char ***matrixOut, int *matrixOutSize)
|
||||
{
|
||||
if (SWIG_SciString_FromCharPtrArray(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$2, *$1) == SWIG_OK)
|
||||
if (SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$2, *$1) == SWIG_OK)
|
||||
{
|
||||
SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
|
||||
}
|
||||
|
|
@ -172,7 +194,7 @@
|
|||
|
||||
%typemap(argout, noblock=1, fragment="SWIG_SciString_FromCharPtrArrayAndSize") (int *matrixOutSize, char ***matrixOut)
|
||||
{
|
||||
if (SWIG_SciString_FromCharPtrArray(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$1, *$2) == SWIG_OK)
|
||||
if (SWIG_SciString_FromCharPtrArrayAndSize(pvApiCtx, SWIG_Scilab_GetOutputPosition(), 1, *$1, *$2) == SWIG_OK)
|
||||
{
|
||||
SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue