jyapayne/swig
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

scilab: test *matrix, size) array typemaps

Browse source
This commit is contained in:
Simon Marchetto 2014-03-26 14:39:34 +01:00
commit a4979d8d7e
3 changed files with 149 additions and 96 deletions
Download patch file Download diff file Expand all files Collapse all files

60
Examples/test-suite/scilab/scilab_li_matrix_runme.sci
View file

@ -3,62 +3,66 @@
exec("swigtest.start", -1); exec("swigtest.start", -1);
// test matrix passed as output argument from fonction // test matrix passed as output argument from fonction
function test_out_matrix(value_type, expected_out_matrix) function test_out_matrix(func, value_type, expected_out_matrix)
func_name = msprintf("out_%s_matrix_func", value_type); func_name = msprintf("out_%s_%s", value_type, func);
cmd = msprintf("out_matrix = %s();", func_name); cmd = msprintf("out_matrix = %s();", func_name);
ierr = execstr(cmd, "errcatch"); ierr = execstr(cmd, "errcatch");
if ierr <> 0 then if ierr <> 0 then
swigtesterror(msprintf("Error %d in %s", ierr, func_name)); swigtesterror(msprintf("Error %d in %s", ierr, func_name));
end end
if ~isdef('out_matrix') | ~isequal(out_matrix, expected_out_matrix) then checkequal(out_matrix, expected_out_matrix, func_name);
swigtesterror(msprintf("Wrong value returned from %s()", func_name));
end
endfunction endfunction
// test matrix passed as input argument of fonction // test matrix passed as input argument of fonction
function test_in_matrix(value_type, in_matrix, expected_in_value) function test_in_matrix(func, value_type, in_matrix, expected_in_value)
func_name = msprintf("in_%s_matrix_func", value_type); func_name = msprintf("in_%s_%s", value_type, func);
cmd = msprintf("in_value = %s(in_matrix);", func_name); cmd = msprintf("in_value = %s(in_matrix);", func_name);
ierr = execstr(cmd, "errcatch"); ierr = execstr(cmd, "errcatch");
if ierr <> 0 then if ierr <> 0 then
swigtesterror(msprintf("Error %d in %s", ierr, func_name)); swigtesterror(msprintf("Error %d in %s", ierr, func_name));
end end
if ~isdef('in_value') | ~isequal(in_value, expected_in_value) then checkequal(in_value, expected_in_value, func_name);
swigtesterror(msprintf("Wrong value returned from %s()", func_name));
end
endfunction endfunction
// test matrixes passed as input and output arguments of fonction // test matrixes passed as input and output arguments of fonction
function test_inout_matrix(value_type, inout_matrix, expected_inout_matrix) function test_inout_matrix(func, value_type, inout_matrix, expected_inout_matrix)
func_name = msprintf("inout_%s_matrix_func", value_type); func_name = msprintf("inout_%s_%s", value_type, func);
cmd = msprintf("inout_matrix = %s(inout_matrix);", func_name); cmd = msprintf("inout_matrix = %s(inout_matrix);", func_name);
ierr = execstr(cmd, "errcatch"); ierr = execstr(cmd, "errcatch");
if ierr <> 0 then if ierr <> 0 then
swigtesterror(msprintf("Error %d in %s", ierr, func_name)); swigtesterror(msprintf("Error %d in %s", ierr, func_name));
end end
if ~isdef('inout_matrix') | ~isequal(inout_matrix, expected_inout_matrix) then checkequal(inout_matrix, expected_inout_matrix, func_name);
swigtesterror(msprintf("Wrong value returned from %s()", func_name));
end
endfunction endfunction
function test_matrix_typemaps(value_type, matrix, expected_out_matrix, expected_in_value, expected_inout_matrix) function test_matrix_typemaps(value_type, ..
test_out_matrix(value_type, expected_out_matrix); expected_out_matrix_dims, expected_out_matrix_size, ..
test_in_matrix(value_type, matrix, expected_in_value); expected_in_value, ..
test_inout_matrix(value_type, matrix, expected_inout_matrix); 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 endfunction
m = [0. 3.; 1. 4.; 2. 5.]; m = [0 3; 1 4; 2 5];
test_matrix_typemaps("int", m, m, sum(m), m .* m); v = [0 1 2 3 4 5];
test_matrix_typemaps("int", int32(m), m, sum(m), m .* m); 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"] m = [%T %F; %F %T; %T %F];
test_matrix_typemaps("charptr", m, m, strcat(m), m + m); v = [%T %F %T %F %T %F];
test_matrix_typemaps("bool", m, v, %T, ~m, ~v);
m = [%T, %F; %F, %T; %T, %F];
test_matrix_typemaps("bool", m, m, %T, ~m);
exec("swigtest.quit", -1); exec("swigtest.quit", -1);

157
Examples/test-suite/scilab_li_matrix.i
View file

@ -3,8 +3,10 @@
%include matrix.i %include matrix.i
%define %use_matrix_apply(TYPE...) %define %use_matrix_apply(TYPE...)
%apply (TYPE *matrixIn, int matrixInRowCount, int matrixInColCount) { (TYPE *inputMatrix, int nbRow, int nbCol) } %apply (TYPE *matrixIn, int matrixInRowCount, int matrixInColCount) { (TYPE *matrix, int nbRow, int nbCol) }
%apply (TYPE **matrixOut, int *matrixOutRowCount, int *matrixOutColCount) { (TYPE **resultMatrix, int *nbRowRes, int *nbColRes) } %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 %enddef
%use_matrix_apply(int); %use_matrix_apply(int);
@ -14,113 +16,138 @@
%inline %{ %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; T sum = 0;
int i; int i;
for (i=0; i<nbRow*nbCol; i++) for (i = 0; i < size; i++)
sum += inputMatrix[i]; sum += matrix[i];
return sum; 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 size;
int i; int i;
*nbRowRes = 3; *sizeRes = 6;
*nbColRes = 2; *matrixRes = (T*) malloc(*sizeRes * sizeof(T));
size = (*nbRowRes) * (*nbColRes); for (i = 0; i < *sizeRes; i++)
*resultMatrix = (T*) malloc(size * sizeof(T)); (*matrixRes)[i] = i;
for (i=0; i<size; i++)
(*resultMatrix)[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 i;
int size = nbRow * nbCol; *sizeRes = size;
*nbRowRes = nbRow; *matrixRes = (T*) malloc(size * sizeof(T));
*nbColRes = nbCol; for (i = 0; i < size; i++) {
*resultMatrix = (T*) malloc(size * sizeof(T)); (*matrixRes)[i] = matrix[i] * matrix[i];
for (i=0; i<size; i++) {
(*resultMatrix)[i] = inputMatrix[i] * inputMatrix[i];
} }
} }
// char* matrix functions /*
template<> char* in_matrix_func(char **inputMatrix, int nbRow, int nbCol) { * (char **matrixIn, int matrixInSize) pattern functions
char *s = (char *) malloc(nbRow * nbCol * sizeof(char) + 1); */
template<> char* in_matrix_size(char **matrix, int size) {
char *s = (char *) calloc(size + 1, sizeof(char));
int i; int i;
for (i=0; i<nbRow*nbCol; i++) for (i = 0; i < size; i++)
strcat(s, inputMatrix[i]); strcat(s, matrix[i]);
return s; return s;
} }
template<> void out_matrix_func(char ***resultMatrix, int *nbRowRes, int *nbColRes) { template<> void out_matrix_size(char ***matrixRes, int *sizeRes) {
int size;
char *s; char *s;
int i; int i;
*nbRowRes = 3; *sizeRes = 6;
*nbColRes = 2; *matrixRes = (char **) malloc(*sizeRes * sizeof(char *));
size = (*nbRowRes) * (*nbColRes); for (i = 0; i < *sizeRes; i++) {
*resultMatrix = (char **) malloc(size * sizeof(char *));
for (i=0; i<size; i++) {
s = (char *) malloc(sizeof(char)+1); s = (char *) malloc(sizeof(char)+1);
sprintf(s, "%c", char(65 + i)); 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; int i;
char *s; char *s;
int size = nbRow * nbCol; *sizeRes = size;
*nbRowRes = nbRow; *matrixRes = (char **) malloc(*sizeRes * sizeof(char* ));
*nbColRes = nbCol; for (i = 0; i < *sizeRes; i++) {
*resultMatrix = (char **) malloc(size * sizeof(char* )); s = (char *) malloc((2 * strlen(matrix[i]) + 1) * sizeof(char));
for (i=0; i<size; i++) { sprintf(s, "%s%s", matrix[i], matrix[i]);
s = (char *) malloc((2 * strlen(inputMatrix[i]) + 1) * sizeof(char)); (*matrixRes)[i] = s;
sprintf(s, "%s%s", inputMatrix[i], inputMatrix[i]);
(*resultMatrix)[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; bool b = true;
int i; int i;
b = inputMatrix[0]; b = matrix[0];
for (i=1; i<nbRow*nbCol; i++) for (i = 1; i < size; i++)
b = b ^ inputMatrix[i]; b = b ^ matrix[i];
return b; return b;
} }
template<> void out_matrix_func(bool **resultMatrix, int *nbRowRes, int *nbColRes) { template<> void out_matrix_size(bool **matrixRes, int *sizeRes) {
int size;
int i; int i;
*nbRowRes = 3; *sizeRes = 6;
*nbColRes = 2; *matrixRes = (bool*) malloc(*sizeRes * sizeof(bool));
size = (*nbRowRes) * (*nbColRes); for (i = 0; i < *sizeRes; i++) {
*resultMatrix = (bool*) malloc(size * sizeof(bool)); (*matrixRes)[i] = i % 2 == 0;
for (i=0; i<size; i++) {
(*resultMatrix)[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 i;
int size = nbRow * nbCol; *sizeRes = size;
*nbRowRes = nbRow; *matrixRes = (bool*) malloc(*sizeRes * sizeof(bool));
*nbColRes = nbCol; for (i = 0; i < *sizeRes; i++) {
*resultMatrix = (bool*) malloc(size * sizeof(bool)); (*matrixRes)[i] = matrix[i] == 1 ? 0 : 1;
for (i=0; i<size; i++) {
(*resultMatrix)[i] = inputMatrix[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...) %define %instantiate_matrix_template_functions(NAME, TYPE...)
%template(in_ ## NAME ## _matrix_func) in_matrix_func<TYPE>; %template(in_ ## NAME ## _matrix_dims) in_matrix_dims<TYPE>;
%template(out_ ## NAME ## _matrix_func) out_matrix_func<TYPE>; %template(out_ ## NAME ## _matrix_dims) out_matrix_dims<TYPE>;
%template(inout_ ## NAME ## _matrix_func) inout_matrix_func<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 %enddef
%instantiate_matrix_template_functions(int, int); %instantiate_matrix_template_functions(int, int);

28
Lib/scilab/scimatrixchar.swg
View file

@ -29,7 +29,29 @@
%typemap(in, noblock=1, fragment="SWIG_SciString_AsCharPtrArrayAndSize") (char **matrixIn, int matrixInSize) %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; return SWIG_ERROR;
} }
@ -138,7 +160,7 @@
%typemap(argout, noblock=1, fragment="SWIG_SciString_FromCharPtrArrayAndSize") (char ***matrixOut, int *matrixOutSize) %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()); 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) %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()); SWIG_Scilab_SetOutput(pvApiCtx, SWIG_NbInputArgument(pvApiCtx) + SWIG_Scilab_GetOutputPosition());
} }