diff options
Diffstat (limited to 'src/c')
159 files changed, 3821 insertions, 7 deletions
diff --git a/src/c/auxiliaryFunctions/includes/sign.h b/src/c/auxiliaryFunctions/includes/sign.h index 0f69b4b..67f0da8 100644 --- a/src/c/auxiliaryFunctions/includes/sign.h +++ b/src/c/auxiliaryFunctions/includes/sign.h @@ -18,6 +18,7 @@ #include "dynlib_auxiliaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -56,6 +57,38 @@ EXTERN_AUXFUNCT floatComplex csigns(floatComplex in); EXTERN_AUXFUNCT doubleComplex zsigns(doubleComplex in); /** + ** \brief Uint8 Sign function + ** Determine the sign of in (assume that 0 is positive). + ** \param in : the uint8 we must determine sign. + ** \return -1 or +1 depending on the sign of in. + **/ +EXTERN_AUXFUNCT int8 u8signs(uint8 in); + +/** + ** \brief Int8 Sign function + ** Determine the sign of in (assume that 0 is positive). + ** \param in : the int8 we must determine sign. + ** \return -1 or +1 depending on the sign of in. + **/ +EXTERN_AUXFUNCT int8 i8signs(int8 in); + +/** + ** \brief Uint16 Sign function + ** Determine the sign of in (assume that 0 is positive). + ** \param in : the uint16 we must determine sign. + ** \return -1 or +1 depending on the sign of in. + **/ +EXTERN_AUXFUNCT int16 u16signs(uint16 in); + +/** + ** \brief Int16 Sign function + ** Determine the sign of in (assume that 0 is positive). + ** \param in : the uint16 we must determine sign. + ** \return -1 or +1 depending on the sign of in. + **/ +EXTERN_AUXFUNCT int16 i16signs(int16 in); + +/** ** \brief Float Signe Array function ** Determine the sign of an array in (assume that 0 is positive). ** \param in : the float array we must determine sign. @@ -91,6 +124,43 @@ EXTERN_AUXFUNCT void csigna(floatComplex *in, int size, floatComplex *out); **/ EXTERN_AUXFUNCT void zsigna(doubleComplex *in, int size, doubleComplex *out); +/** + ** \brief Uint8 Sign Array function + ** Determine the sign of an array in (assume that 0 is positive). + ** \param in : the uint8 array we must determine sign. + ** \param size : the number of elements. + ** \return -1 or +1 depending on the sign of in elements. + **/ +EXTERN_AUXFUNCT void u8signa(uint8 *in, int size, int8 *out); + +/** + ** \brief Int8 Sign Array function + ** Determine the sign of an array in (assume that 0 is positive). + ** \param in : the int8 array we must determine sign. + ** \param size : the number of elements. + ** \return -1 or +1 depending on the sign of in elements. + **/ +EXTERN_AUXFUNCT void i8signa(int8 *in, int size, int8 *out); + +/** + ** \brief Uint16 Sign Array function + ** Determine the sign of an array in (assume that 0 is positive). + ** \param in : the uint16 array we must determine sign. + ** \param size : the number of elements. + ** \return -1 or +1 depending on the sign of in elements. + **/ +EXTERN_AUXFUNCT void u16signa(uint16 *in, int size, int16 *out); + +/** + ** \brief Int16 Sign Array function + ** Determine the sign of an array in (assume that 0 is positive). + ** \param in : the int16 array we must determine sign. + ** \param size : the number of elements. + ** \return -1 or +1 depending on the sign of in elements. + **/ +EXTERN_AUXFUNCT void i16signa(int16 *in, int size, int16 *out); + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/auxiliaryFunctions/interfaces/int_sign.h b/src/c/auxiliaryFunctions/interfaces/int_sign.h index 4463901..1003fe7 100644 --- a/src/c/auxiliaryFunctions/interfaces/int_sign.h +++ b/src/c/auxiliaryFunctions/interfaces/int_sign.h @@ -23,6 +23,14 @@ #define z0signz0(in) zsigns(in) +#define u80signi80(in) u8signs(in) + +#define i80signi80(in) i8signs(in) + +#define u160signi160(in) u16signs(in) + +#define i160signi160(in) i16signs(in) + #define s2signs2(in,size,out) ssigna(in, size[0]*size[1], out) #define d2signd2(in,size,out) dsigna(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2signz2(in,size,out) zsigna(in, size[0]*size[1], out) +#define u82signi82(in,size,out) u8signa(in, size[0]*size[1], out) + +#define i82signi82(in,size,out) i8signa(in, size[0]*size[1], out) + +#define u162signi162(in,size,out) u16signa(in, size[0]*size[1], out) + +#define i162signi162(in,size,out) i16signa(in, size[0]*size[1], out) + #endif /* !__INT_SIGN_H__ */ diff --git a/src/c/auxiliaryFunctions/sign/i16signa.c b/src/c/auxiliaryFunctions/sign/i16signa.c new file mode 100644 index 0000000..c1d9e91 --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/i16signa.c @@ -0,0 +1,21 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +void i16signa(int16 *in, int size, int16 *out) { + int i = 0; + + for (i = 0 ; i < size ; ++i) { + out[i] = i16signs(in[i]); + } +} diff --git a/src/c/auxiliaryFunctions/sign/i16signs.c b/src/c/auxiliaryFunctions/sign/i16signs.c new file mode 100644 index 0000000..a3a11ab --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/i16signs.c @@ -0,0 +1,24 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +int16 i16signs(int16 num) { + if (num > 0) { + return (int16)1; + } + if (num < 0) { + return (int16)-1; + } + /* num == 0 */ + return (int16)0; +} diff --git a/src/c/auxiliaryFunctions/sign/i8signa.c b/src/c/auxiliaryFunctions/sign/i8signa.c new file mode 100644 index 0000000..c86e0fb --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/i8signa.c @@ -0,0 +1,21 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +void i8signa(int8 *in, int size, int8 *out) { + int i = 0; + + for (i = 0 ; i < size ; ++i) { + out[i] = i8signs(in[i]); + } +} diff --git a/src/c/auxiliaryFunctions/sign/i8signs.c b/src/c/auxiliaryFunctions/sign/i8signs.c new file mode 100644 index 0000000..ced00a7 --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/i8signs.c @@ -0,0 +1,24 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +int8 i8signs(int8 num) { + if (num > 0) { + return (int8)1; + } + if (num < 0) { + return (int8)-1; + } + /* num == 0 */ + return (int8)0; +} diff --git a/src/c/auxiliaryFunctions/sign/u16signa.c b/src/c/auxiliaryFunctions/sign/u16signa.c new file mode 100644 index 0000000..3cc4f66 --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/u16signa.c @@ -0,0 +1,21 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +void u16signa(uint16 *in, int size, int16 *out) { + int i = 0; + + for (i = 0 ; i < size ; ++i) { + out[i] = u16signs(in[i]); + } +} diff --git a/src/c/auxiliaryFunctions/sign/u16signs.c b/src/c/auxiliaryFunctions/sign/u16signs.c new file mode 100644 index 0000000..7f18722 --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/u16signs.c @@ -0,0 +1,24 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +int16 u16signs(uint16 num) { + if (num > 0) { + return (int16)1; + } + if (num < 0) { + return (int16)-1; + } + /* num == 0 */ + return (int16)0; +} diff --git a/src/c/auxiliaryFunctions/sign/u8signa.c b/src/c/auxiliaryFunctions/sign/u8signa.c new file mode 100644 index 0000000..34021b5 --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/u8signa.c @@ -0,0 +1,21 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +void u8signa(uint8 *in, int size, int8 *out) { + int i = 0; + + for (i = 0 ; i < size ; ++i) { + out[i] = u8signs(in[i]); + } +} diff --git a/src/c/auxiliaryFunctions/sign/u8signs.c b/src/c/auxiliaryFunctions/sign/u8signs.c new file mode 100644 index 0000000..437da77 --- /dev/null +++ b/src/c/auxiliaryFunctions/sign/u8signs.c @@ -0,0 +1,24 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2007-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sign.h" + +int8 u8signs(uint8 num) { + if (num > 0) { + return (int8)1; + } + if (num < 0) { + return (int8)-1; + } + /* num == 0 */ + return (int8)0; +} diff --git a/src/c/elementaryFunctions/cos/i16cosa.c b/src/c/elementaryFunctions/cos/i16cosa.c new file mode 100644 index 0000000..fb3c637 --- /dev/null +++ b/src/c/elementaryFunctions/cos/i16cosa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "cos.h" + +void i16cosa(int16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i16coss(x[i]); + } +} diff --git a/src/c/elementaryFunctions/cos/i16coss.c b/src/c/elementaryFunctions/cos/i16coss.c new file mode 100644 index 0000000..a46f8e2 --- /dev/null +++ b/src/c/elementaryFunctions/cos/i16coss.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "cos.h" + +float i16coss(int16 x) { + return (cos(x)); +} diff --git a/src/c/elementaryFunctions/cos/i8cosa.c b/src/c/elementaryFunctions/cos/i8cosa.c new file mode 100644 index 0000000..7517b31 --- /dev/null +++ b/src/c/elementaryFunctions/cos/i8cosa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "cos.h" + +void i8cosa(int8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i8coss(x[i]); + } +} diff --git a/src/c/elementaryFunctions/cos/i8coss.c b/src/c/elementaryFunctions/cos/i8coss.c new file mode 100644 index 0000000..cd09e06 --- /dev/null +++ b/src/c/elementaryFunctions/cos/i8coss.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "cos.h" + +float i8coss(int8 x) { + return (cos(x)); +} diff --git a/src/c/elementaryFunctions/cos/u16cosa.c b/src/c/elementaryFunctions/cos/u16cosa.c new file mode 100644 index 0000000..63bbdae --- /dev/null +++ b/src/c/elementaryFunctions/cos/u16cosa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "cos.h" + +void u16cosa(uint16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u16coss(x[i]); + } +} diff --git a/src/c/elementaryFunctions/cos/u16coss.c b/src/c/elementaryFunctions/cos/u16coss.c new file mode 100644 index 0000000..95971fe --- /dev/null +++ b/src/c/elementaryFunctions/cos/u16coss.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "cos.h" + +float u16coss(uint16 x) { + return (cos(x)); +} diff --git a/src/c/elementaryFunctions/cos/u8cosa.c b/src/c/elementaryFunctions/cos/u8cosa.c new file mode 100644 index 0000000..25de95e --- /dev/null +++ b/src/c/elementaryFunctions/cos/u8cosa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "cos.h" + +void u8cosa(uint8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u8coss(x[i]); + } +} diff --git a/src/c/elementaryFunctions/cos/u8coss.c b/src/c/elementaryFunctions/cos/u8coss.c new file mode 100644 index 0000000..9ee1186 --- /dev/null +++ b/src/c/elementaryFunctions/cos/u8coss.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "cos.h" + +float u8coss(uint8 x) { + return (cos(x)); +} diff --git a/src/c/elementaryFunctions/cosh/i16cosha.c b/src/c/elementaryFunctions/cosh/i16cosha.c new file mode 100644 index 0000000..8515bc7 --- /dev/null +++ b/src/c/elementaryFunctions/cosh/i16cosha.c @@ -0,0 +1,26 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" + +float i16coshs(int16 x) { + float y = i16exps(i16abss(x)); + return (0.5f * (y + 1.0f / y)); +} diff --git a/src/c/elementaryFunctions/cosh/i16coshs.c b/src/c/elementaryFunctions/cosh/i16coshs.c new file mode 100644 index 0000000..7d6084f --- /dev/null +++ b/src/c/elementaryFunctions/cosh/i16coshs.c @@ -0,0 +1,27 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" +#include "types.h" + +float i16coshs(int16 x) { + double y = i16exps(i16abss(x)); + return (0.5 * (y + 1.0/y)); +} diff --git a/src/c/elementaryFunctions/cosh/i8cosha.c b/src/c/elementaryFunctions/cosh/i8cosha.c new file mode 100644 index 0000000..b30c14e --- /dev/null +++ b/src/c/elementaryFunctions/cosh/i8cosha.c @@ -0,0 +1,26 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" + +float i8coshs(int8 x) { + float y = i8exps(i8abss(x)); + return (0.5f * (y + 1.0f / y)); +} diff --git a/src/c/elementaryFunctions/cosh/i8coshs.c b/src/c/elementaryFunctions/cosh/i8coshs.c new file mode 100644 index 0000000..885d119 --- /dev/null +++ b/src/c/elementaryFunctions/cosh/i8coshs.c @@ -0,0 +1,27 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" +#include "types.h" + +float i8coshs(int8 x) { + double y = i8exps(i8abss(x)); + return (0.5 * (y + 1.0/y)); +} diff --git a/src/c/elementaryFunctions/cosh/u16cosha.c b/src/c/elementaryFunctions/cosh/u16cosha.c new file mode 100644 index 0000000..775f710 --- /dev/null +++ b/src/c/elementaryFunctions/cosh/u16cosha.c @@ -0,0 +1,26 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" + +float u16coshs(uint16 x) { + float y = u16exps(u16abss(x)); + return (0.5f * (y + 1.0f / y)); +} diff --git a/src/c/elementaryFunctions/cosh/u16coshs.c b/src/c/elementaryFunctions/cosh/u16coshs.c new file mode 100644 index 0000000..5637bb3 --- /dev/null +++ b/src/c/elementaryFunctions/cosh/u16coshs.c @@ -0,0 +1,27 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" +#include "types.h" + +float u16coshs(uint16 x) { + double y = u16exps(u16abss(x)); + return (0.5 * (y + 1.0/y)); +} diff --git a/src/c/elementaryFunctions/cosh/u8cosha.c b/src/c/elementaryFunctions/cosh/u8cosha.c new file mode 100644 index 0000000..b6d614f --- /dev/null +++ b/src/c/elementaryFunctions/cosh/u8cosha.c @@ -0,0 +1,26 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" + +float u8coshs(uint8 x) { + float y = u8exps(u8abss(x)); + return (0.5f * (y + 1.0f / y)); +} diff --git a/src/c/elementaryFunctions/cosh/u8coshs.c b/src/c/elementaryFunctions/cosh/u8coshs.c new file mode 100644 index 0000000..7a6715f --- /dev/null +++ b/src/c/elementaryFunctions/cosh/u8coshs.c @@ -0,0 +1,27 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* +// cosh(z) = 0.5 (exp(|z|) + exp(-|z|)) +// = 0.5 ( y + 1/y ) with y = exp(|z|) +*/ + +#include <math.h> +#include "cosh.h" +#include "exp.h" +#include "abs.h" +#include "types.h" + +float u8coshs(uint8 x) { + double y = u8exps(u8abss(x)); + return (0.5 * (y + 1.0/y)); +} diff --git a/src/c/elementaryFunctions/exp/i16expa.c b/src/c/elementaryFunctions/exp/i16expa.c new file mode 100644 index 0000000..faa8a12 --- /dev/null +++ b/src/c/elementaryFunctions/exp/i16expa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "exp.h" + +void i16expa(int16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i16exps(x[i]); + } +} diff --git a/src/c/elementaryFunctions/exp/i16exps.c b/src/c/elementaryFunctions/exp/i16exps.c new file mode 100644 index 0000000..97b57d9 --- /dev/null +++ b/src/c/elementaryFunctions/exp/i16exps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "exp.h" + +float i16exps(int16 x) { + return (expf(x)); +} diff --git a/src/c/elementaryFunctions/exp/i8expa.c b/src/c/elementaryFunctions/exp/i8expa.c new file mode 100644 index 0000000..7f731fc --- /dev/null +++ b/src/c/elementaryFunctions/exp/i8expa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "exp.h" + +void i8expa(int8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i8exps(x[i]); + } +} diff --git a/src/c/elementaryFunctions/exp/i8exps.c b/src/c/elementaryFunctions/exp/i8exps.c new file mode 100644 index 0000000..6f2d43c --- /dev/null +++ b/src/c/elementaryFunctions/exp/i8exps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "exp.h" + +float i8exps(int8 x) { + return (expf(x)); +} diff --git a/src/c/elementaryFunctions/exp/u16expa.c b/src/c/elementaryFunctions/exp/u16expa.c new file mode 100644 index 0000000..0426ab4 --- /dev/null +++ b/src/c/elementaryFunctions/exp/u16expa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "exp.h" + +void u16expa(uint16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u16exps(x[i]); + } +} diff --git a/src/c/elementaryFunctions/exp/u16exps.c b/src/c/elementaryFunctions/exp/u16exps.c new file mode 100644 index 0000000..64f5c5b --- /dev/null +++ b/src/c/elementaryFunctions/exp/u16exps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "exp.h" + +float u16exps(uint16 x) { + return (expf(x)); +} diff --git a/src/c/elementaryFunctions/exp/u8expa.c b/src/c/elementaryFunctions/exp/u8expa.c new file mode 100644 index 0000000..bd90e04 --- /dev/null +++ b/src/c/elementaryFunctions/exp/u8expa.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "exp.h" + +void u8expa(uint8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u8exps(x[i]); + } +} diff --git a/src/c/elementaryFunctions/exp/u8exps.c b/src/c/elementaryFunctions/exp/u8exps.c new file mode 100644 index 0000000..e48953f --- /dev/null +++ b/src/c/elementaryFunctions/exp/u8exps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "exp.h" + +float u8exps(uint8 x) { + return (expf(x)); +} diff --git a/src/c/elementaryFunctions/includes/cos.h b/src/c/elementaryFunctions/includes/cos.h index 5d573b1..25c7694 100644 --- a/src/c/elementaryFunctions/includes/cos.h +++ b/src/c/elementaryFunctions/includes/cos.h @@ -16,6 +16,7 @@ #include "dynlib_elementaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -49,6 +50,30 @@ EXTERN_ELEMFUNCT floatComplex ccoss(floatComplex in); EXTERN_ELEMFUNCT doubleComplex zcoss(doubleComplex in); /* +** \brief Uint8 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u8coss(uint8 in); + +/* +** \brief Int8 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i8coss(int8 in); + +/* +** \brief Uint16 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u16coss(uint16 in); + +/* +** \brief Int8 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i16coss(int16 in); + +/* ** \brief Float Matrix Cosine function ** \param in : input array value. ** \param out : output array value. @@ -80,6 +105,38 @@ EXTERN_ELEMFUNCT void ccosa(floatComplex* in, int size, floatComplex* out); */ EXTERN_ELEMFUNCT void zcosa(doubleComplex* in, int size, doubleComplex* out); +/* +** \brief uint8 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u8cosa(uint8* in, int size, float* out); + +/* +** \brief int8 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i8cosa(int8* in, int size, float* out); + +/* +** \brief uint16 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u16cosa(uint16* in, int size, float* out); + +/* +** \brief int16 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i16cosa(int16* in, int size, float* out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/cosh.h b/src/c/elementaryFunctions/includes/cosh.h index 0cbf8eb..e084e42 100644 --- a/src/c/elementaryFunctions/includes/cosh.h +++ b/src/c/elementaryFunctions/includes/cosh.h @@ -16,6 +16,7 @@ #include "dynlib_elementaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus @@ -50,6 +51,30 @@ EXTERN_ELEMFUNCT floatComplex ccoshs(floatComplex in); EXTERN_ELEMFUNCT doubleComplex zcoshs(doubleComplex in); /* +** \brief uint8 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u8coshs(uint8 in); + +/* +** \brief int8 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i8coshs(int8 in); + +/* +** \brief uint16 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u16coshs(uint16 in); + +/* +** \brief int16 Cosine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i16coshs(int16 in); + +/* ** \brief Float Matrix Cosine function ** \param in : input array value. ** \param out : output array value. @@ -81,6 +106,39 @@ EXTERN_ELEMFUNCT void ccosha(floatComplex* in, int size, floatComplex* out); */ EXTERN_ELEMFUNCT void zcosha(doubleComplex* in, int size, doubleComplex* out); +/* +** \brief Uint8 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u8cosha(uint8* in, int size, float* out); + +/* +** \brief Int8 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i8cosha(int8* in, int size, float* out); + +/* +** \brief Uint16 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u16cosha(uint16* in, int size, float* out); + +/* +** \brief Int16 Matrix Cosine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i16cosha(int16* in, int size, float* out); + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/exp.h b/src/c/elementaryFunctions/includes/exp.h index 297a576..6e8f027 100644 --- a/src/c/elementaryFunctions/includes/exp.h +++ b/src/c/elementaryFunctions/includes/exp.h @@ -16,6 +16,7 @@ #include "dynlib_elementaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus @@ -50,6 +51,30 @@ EXTERN_ELEMFUNCT floatComplex cexps(floatComplex in); EXTERN_ELEMFUNCT doubleComplex zexps(doubleComplex in); /* +** \brief Uint8 Exponential function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u8exps(uint8 in); + +/* +** \brief Int8 Exponential function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i8exps(int8 in); + +/* +** \brief Uint16 Exponential function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u16exps(uint16 in); + +/* +** \brief Int16 Exponential function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i16exps(int16 in); + +/* ** \brief Float Matrix Exponential function ** \param in : input array value. ** \param out : output array value. @@ -81,6 +106,39 @@ EXTERN_ELEMFUNCT void cexpa(floatComplex* in, int size, floatComplex* out); */ EXTERN_ELEMFUNCT void zexpa(doubleComplex* in, int size, doubleComplex* out); +/* +** \brief Uint8 Matrix Exponential function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u8expa(uint8* in, int size, float* out); + +/* +** \brief Int8 Matrix Exponential function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i8expa(int8* in, int size, float* out); + +/* +** \brief Uint16 Matrix Exponential function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u16expa(uint16* in, int size, float* out); + +/* +** \brief Int16 Matrix Exponential function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i16expa(int16* in, int size, float* out); + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/int16.h b/src/c/elementaryFunctions/includes/int16.h index f327184..8c8204f 100644 --- a/src/c/elementaryFunctions/includes/int16.h +++ b/src/c/elementaryFunctions/includes/int16.h @@ -27,12 +27,24 @@ extern "C" { EXTERN_ELEMFUNCT int16 sint16s(float in); -EXTERN_ELEMFUNCT int16 dint816s(double in); +EXTERN_ELEMFUNCT int16 dint16s(double in); + +EXTERN_ELEMFUNCT int16 u8int16s(uint8 in); + +EXTERN_ELEMFUNCT int16 i8int16s(int8 in); + +EXTERN_ELEMFUNCT int16 u16int16s(uint16 in); EXTERN_ELEMFUNCT void sint16a(float* in, int size, int16* out); EXTERN_ELEMFUNCT void dint16a(double* in, int size, int16* out); +EXTERN_ELEMFUNCT void u8int16a(uint8* in, int size, int16* out); + +EXTERN_ELEMFUNCT void i8int16a(int8* in, int size, int16* out); + +EXTERN_ELEMFUNCT void u16int16a(uint16* in, int size, int16* out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/int8.h b/src/c/elementaryFunctions/includes/int8.h index 12fc595..795190e 100644 --- a/src/c/elementaryFunctions/includes/int8.h +++ b/src/c/elementaryFunctions/includes/int8.h @@ -27,12 +27,24 @@ extern "C" { EXTERN_ELEMFUNCT int8 sint8s(float in); -EXTERN_ELEMFUNCT int8 dint8s(double in); +EXTERN_ELEMFUNCT int8 dint8s(double in); + +EXTERN_ELEMFUNCT int8 u8int8s(uint8 in); + +EXTERN_ELEMFUNCT int8 u16int8s(uint16 in); + +EXTERN_ELEMFUNCT int8 i16int8s(int16 in); EXTERN_ELEMFUNCT void sint8a(float* in, int size, int8* out); EXTERN_ELEMFUNCT void dint8a(double* in, int size, int8* out); +EXTERN_ELEMFUNCT void u8int8a(uint8* in, int size, int8* out); + +EXTERN_ELEMFUNCT void u16int8a(uint16* in, int size, int8* out); + +EXTERN_ELEMFUNCT void i16int8a(int16* in, int size, int8* out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/sin.h b/src/c/elementaryFunctions/includes/sin.h index 198b066..ffb7626 100644 --- a/src/c/elementaryFunctions/includes/sin.h +++ b/src/c/elementaryFunctions/includes/sin.h @@ -16,6 +16,7 @@ #include "dynlib_elementaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -49,6 +50,33 @@ EXTERN_ELEMFUNCT floatComplex csins(floatComplex in); EXTERN_ELEMFUNCT doubleComplex zsins(doubleComplex in); /* +** \brief Uint8 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u8sins(uint8 in); + + +/* +** \brief Int8 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i8sins(int8 in); + + +/* +** \brief Uint16 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u16sins(uint16 in); + + +/* +** \brief Int16 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i16sins(int16 in); + +/* ** \brief Float Matrix Sine function ** \param in : input array value. ** \param out : output array value. @@ -80,6 +108,39 @@ EXTERN_ELEMFUNCT void csina(floatComplex* in, int size, floatComplex* out); */ EXTERN_ELEMFUNCT void zsina(doubleComplex* in, int size, doubleComplex* out); +/* +** \brief uint8 Matrix Sine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u8sina(uint8* in, int size, float* out); + +/* +** \brief int8 Matrix Sine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i8sina(int8* in, int size, float* out); + +/* +** \brief uint16 Matrix Sine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u16sina(uint16* in, int size, float* out); + +/* +** \brief int16 Matrix Sine function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i16sina(int16* in, int size, float* out); + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/sinh.h b/src/c/elementaryFunctions/includes/sinh.h index c052a90..c464fce 100644 --- a/src/c/elementaryFunctions/includes/sinh.h +++ b/src/c/elementaryFunctions/includes/sinh.h @@ -16,6 +16,7 @@ #include "dynlib_elementaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -48,6 +49,31 @@ EXTERN_ELEMFUNCT floatComplex csinhs(floatComplex in); */ EXTERN_ELEMFUNCT doubleComplex zsinhs(doubleComplex in); + +/* +** \brief Uint8 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u8sinhs(uint8 in); + +/* +** \brief Int8 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i8sinhs(int8 in); + +/* +** \brief Uint16 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u16sinhs(uint16 in); + +/* +** \brief Int16 Sine function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i16sinhs(int16 in); + /* ** \brief Float Matrix Sine function ** \param in : input array value. @@ -80,6 +106,39 @@ EXTERN_ELEMFUNCT void csinha(floatComplex* in, int size, floatComplex* out); */ EXTERN_ELEMFUNCT void zsinha(doubleComplex* in, int size, doubleComplex* out); +/* +** \brief Uint8 Matrix Sine function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u8sinha(uint8* in, int size, float* out); + +/* +** \brief Int8 Matrix Sine function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i8sinha(int8* in, int size, float* out); + +/* +** \brief Uint16 Matrix Sine function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u16sinha(uint16* in, int size, float* out); + +/* +** \brief Int16 Matrix Sine function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i16sinha(int16* in, int size, float* out); + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/tan.h b/src/c/elementaryFunctions/includes/tan.h index 77ef786..2632a77 100644 --- a/src/c/elementaryFunctions/includes/tan.h +++ b/src/c/elementaryFunctions/includes/tan.h @@ -16,6 +16,7 @@ #include "dynlib_elementaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -49,6 +50,31 @@ EXTERN_ELEMFUNCT floatComplex ctans(floatComplex in); EXTERN_ELEMFUNCT doubleComplex ztans(doubleComplex in); /* +** \brief Uint8 Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u8tans(uint8 in); + +/* +** \brief Int8 Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i8tans(int8 in); + +/* +** \brief Uint16 Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u16tans(uint16 in); + +/* +** \brief Int16 Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i16tans(int16 in); + + +/* ** \brief Float Matrix Tangeant function ** \param in : input array value. ** \param out : input array value. @@ -80,6 +106,39 @@ EXTERN_ELEMFUNCT void ctana(floatComplex* in, int size, floatComplex* out); */ EXTERN_ELEMFUNCT void ztana(doubleComplex* in, int size, doubleComplex* out); +/* +** \brief Uint8 Matrix Tangeant function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u8tana(uint8* in, int size, float* out); + +/* +** \brief Int8 Matrix Tangeant function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i8tana(int8* in, int size, float* out); + +/* +** \brief Uint16 Matrix Tangeant function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u16tana(uint16* in, int size, float* out); + +/* +** \brief Int16 Matrix Tangeant function +** \param in : input array value. +** \param out : input array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i16tana(int16* in, int size, float* out); + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/tanh.h b/src/c/elementaryFunctions/includes/tanh.h index 9ff440c..6a65423 100644 --- a/src/c/elementaryFunctions/includes/tanh.h +++ b/src/c/elementaryFunctions/includes/tanh.h @@ -16,6 +16,7 @@ #include "dynlib_elementaryfunctions.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "sinh.h" #ifdef __cplusplus extern "C" { @@ -49,6 +50,30 @@ EXTERN_ELEMFUNCT floatComplex ctanhs(floatComplex in); EXTERN_ELEMFUNCT doubleComplex ztanhs(doubleComplex in); /* +** \brief Uint8 Hyperbolic Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u8tanhs(uint8 in); + +/* +** \brief Int8 Hyperbolic Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i8tanhs(int8 in); + +/* +** \brief Uint16 Hyperbolic Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float u16tanhs(uint16 in); + +/* +** \brief Int16 Hyperbolic Tangeant function +** \param in : input value. +*/ +EXTERN_ELEMFUNCT float i16tanhs(int16 in); + +/* ** \brief Float Matrix Hyperbolic Tangeant function ** \param in : input array value. ** \param out : output array value. @@ -80,6 +105,38 @@ EXTERN_ELEMFUNCT void ctanha(floatComplex* in, int size, floatComplex* out); */ EXTERN_ELEMFUNCT void ztanha(doubleComplex* in, int size, doubleComplex* out); +/* +** \brief Uint8 Matrix Hyperbolic Tangeant function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u8tanha(uint8* in, int size, float* out); + +/* +** \brief Int8 Matrix Hyperbolic Tangeant function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i8tanha(int8* in, int size, float* out); + +/* +** \brief Uint16 Matrix Hyperbolic Tangeant function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void u16tanha(uint16* in, int size, float* out); + +/* +** \brief Int16 Matrix Hyperbolic Tangeant function +** \param in : input array value. +** \param out : output array value. +** \param size : the size of in and out arrays. +*/ +EXTERN_ELEMFUNCT void i16tanha(int16* in, int size, float* out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/uint16.h b/src/c/elementaryFunctions/includes/uint16.h index a0739b6..98625e6 100644 --- a/src/c/elementaryFunctions/includes/uint16.h +++ b/src/c/elementaryFunctions/includes/uint16.h @@ -27,12 +27,24 @@ extern "C" { EXTERN_ELEMFUNCT uint16 suint16s(float in); -EXTERN_ELEMFUNCT uint16 duint816s(double in); +EXTERN_ELEMFUNCT uint16 duint16s(double in); + +EXTERN_ELEMFUNCT uint16 u8uint16s(uint8 in); + +EXTERN_ELEMFUNCT uint16 i8uint16s(int8 in); + +EXTERN_ELEMFUNCT uint16 i16uint16s(int16 in); EXTERN_ELEMFUNCT void suint16a(float* in, int size, uint16* out); EXTERN_ELEMFUNCT void duint16a(double* in, int size, uint16* out); +EXTERN_ELEMFUNCT void u8uint16a(uint8* in, int size, uint16* out); + +EXTERN_ELEMFUNCT void i8uint16a(int8* in, int size, uint16* out); + +EXTERN_ELEMFUNCT void i16uint16a(int16* in, int size, uint16* out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/includes/uint8.h b/src/c/elementaryFunctions/includes/uint8.h index 9d3dd39..264230a 100644 --- a/src/c/elementaryFunctions/includes/uint8.h +++ b/src/c/elementaryFunctions/includes/uint8.h @@ -29,10 +29,22 @@ EXTERN_ELEMFUNCT uint8 suint8s(float in); EXTERN_ELEMFUNCT uint8 duint8s(double in); +EXTERN_ELEMFUNCT uint8 i8uint8s(int8 in); + +EXTERN_ELEMFUNCT uint8 u16uint8s(uint16 in); + +EXTERN_ELEMFUNCT uint8 i16uint8s(int16 in); + EXTERN_ELEMFUNCT void suint8a(float* in, int size, uint8* out); EXTERN_ELEMFUNCT void duint8a(double* in, int size, uint8* out); +EXTERN_ELEMFUNCT void i8uint8a(int8* in, int size, uint8* out); + +EXTERN_ELEMFUNCT void u16uint8a(uint16* in, int size, uint8* out); + +EXTERN_ELEMFUNCT void i16uint8a(int16* in, int size, uint8* out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/elementaryFunctions/int16/i8int16a.c b/src/c/elementaryFunctions/int16/i8int16a.c new file mode 100644 index 0000000..82c637c --- /dev/null +++ b/src/c/elementaryFunctions/int16/i8int16a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "int16.h" + +void i8int16a(int8* x, int size, int16* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = i8int16s(x[i]); +} diff --git a/src/c/elementaryFunctions/int16/i8int16s.c b/src/c/elementaryFunctions/int16/i8int16s.c new file mode 100644 index 0000000..a7a2379 --- /dev/null +++ b/src/c/elementaryFunctions/int16/i8int16s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "int16.h" + +int16 i8int16s(int8 x) { + return (int16) x; +} diff --git a/src/c/elementaryFunctions/int16/u16int16a.c b/src/c/elementaryFunctions/int16/u16int16a.c new file mode 100644 index 0000000..e6756d3 --- /dev/null +++ b/src/c/elementaryFunctions/int16/u16int16a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "int16.h" + +void u16int16a(uint16* x, int size, int16* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = u16int16s(x[i]); +} diff --git a/src/c/elementaryFunctions/int16/u16int16s.c b/src/c/elementaryFunctions/int16/u16int16s.c new file mode 100644 index 0000000..26f32b2 --- /dev/null +++ b/src/c/elementaryFunctions/int16/u16int16s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "int16.h" + +int16 u16int16s(uint16 x) { + return (int16) x; +} diff --git a/src/c/elementaryFunctions/int16/u8int16a.c b/src/c/elementaryFunctions/int16/u8int16a.c new file mode 100644 index 0000000..8ed290a --- /dev/null +++ b/src/c/elementaryFunctions/int16/u8int16a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "int16.h" + +void u8int16a(uint8* x, int size, int16* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = u8int16s(x[i]); +} diff --git a/src/c/elementaryFunctions/int16/u8int16s.c b/src/c/elementaryFunctions/int16/u8int16s.c new file mode 100644 index 0000000..29132af --- /dev/null +++ b/src/c/elementaryFunctions/int16/u8int16s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "int16.h" + +int16 u8int16s(uint8 x) { + return (int16) x; +} diff --git a/src/c/elementaryFunctions/int8/i16int8a.c b/src/c/elementaryFunctions/int8/i16int8a.c new file mode 100644 index 0000000..311b751 --- /dev/null +++ b/src/c/elementaryFunctions/int8/i16int8a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "int8.h" + +void i16int8a(int16* x, int size, int8* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = i16int8s(x[i]); +} diff --git a/src/c/elementaryFunctions/int8/i16int8s.c b/src/c/elementaryFunctions/int8/i16int8s.c new file mode 100644 index 0000000..e66b35d --- /dev/null +++ b/src/c/elementaryFunctions/int8/i16int8s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "int8.h" + +int8 i16int8s(int16 x) { + return (int8) x; +} diff --git a/src/c/elementaryFunctions/int8/u16int8a.c b/src/c/elementaryFunctions/int8/u16int8a.c new file mode 100644 index 0000000..3db0c92 --- /dev/null +++ b/src/c/elementaryFunctions/int8/u16int8a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "int8.h" + +void u16int8a(uint16* x, int size, int8* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = u16int8s(x[i]); +} diff --git a/src/c/elementaryFunctions/int8/u16int8s.c b/src/c/elementaryFunctions/int8/u16int8s.c new file mode 100644 index 0000000..b59c677 --- /dev/null +++ b/src/c/elementaryFunctions/int8/u16int8s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "int8.h" + +int8 u16int8s(uint16 x) { + return (int8) x; +} diff --git a/src/c/elementaryFunctions/int8/u8int8a.c b/src/c/elementaryFunctions/int8/u8int8a.c new file mode 100644 index 0000000..2bee86a --- /dev/null +++ b/src/c/elementaryFunctions/int8/u8int8a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "int8.h" + +void u8int8a(uint8* x, int size, int8* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = u8int8s(x[i]); +} diff --git a/src/c/elementaryFunctions/int8/u8int8s.c b/src/c/elementaryFunctions/int8/u8int8s.c new file mode 100644 index 0000000..2c2fa07 --- /dev/null +++ b/src/c/elementaryFunctions/int8/u8int8s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "int8.h" + +int8 u8int8s(uint8 x) { + return (int8) x; +} diff --git a/src/c/elementaryFunctions/interfaces/int_cos.h b/src/c/elementaryFunctions/interfaces/int_cos.h index 647bff6..b19bcfc 100644 --- a/src/c/elementaryFunctions/interfaces/int_cos.h +++ b/src/c/elementaryFunctions/interfaces/int_cos.h @@ -23,6 +23,14 @@ #define z0cosz0(in) zcoss(in) +#define u80coss0(in) u8coss(in) + +#define i80coss0(in) i8coss(in) + +#define u160coss0(in) u16coss(in) + +#define i160coss0(in) i16coss(in) + #define s2coss2(in,size,out) scosa(in, size[0]*size[1], out) #define d2cosd2(in,size,out) dcosa(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2cosz2(in,size,out) zcosa(in, size[0]*size[1], out) +#define u82coss2(in,size,out) u8cosa(in, size[0]*size[1], out) + +#define i82coss2(in,size,out) i8cosa(in, size[0]*size[1], out) + +#define u162coss2(in,size,out) u16cosa(in, size[0]*size[1], out) + +#define i162coss2(in,size,out) i16cosa(in, size[0]*size[1], out) + #endif /* !__INT_COS_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_cosh.h b/src/c/elementaryFunctions/interfaces/int_cosh.h index 28915ca..c2b97ad 100644 --- a/src/c/elementaryFunctions/interfaces/int_cosh.h +++ b/src/c/elementaryFunctions/interfaces/int_cosh.h @@ -23,6 +23,14 @@ #define z0coshz0(in) zcoshs(in) +#define u80coshs0(in) u8coshs(in) + +#define i80coshs0(in) i8coshs(in) + +#define u160coshs0(in) u16coshs(in) + +#define i160coshs0(in) i16coshs(in) + #define s2coshs2(in,size,out) scosha(in, size[0]*size[1], out) #define d2coshd2(in,size,out) dcosha(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2coshz2(in,size,out) zcosha(in, size[0]*size[1], out) +#define u82coshs2(in,size,out) u8cosha(in, size[0]*size[1], out) + +#define i82coshs2(in,size,out) i8cosha(in, size[0]*size[1], out) + +#define u162coshs2(in,size,out) u16cosha(in, size[0]*size[1], out) + +#define i162coshs2(in,size,out) i16cosha(in, size[0]*size[1], out) + #endif /* !__INT_COSH_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_exp.h b/src/c/elementaryFunctions/interfaces/int_exp.h index 3727e3b..bcb8dd9 100644 --- a/src/c/elementaryFunctions/interfaces/int_exp.h +++ b/src/c/elementaryFunctions/interfaces/int_exp.h @@ -23,6 +23,14 @@ #define z0expz0(in) zexps(in) +#define u80exps0(in) u8exps(in) + +#define i80exps0(in) i8exps(in) + +#define u160exps0(in) u16exps(in) + +#define i160exps0(in) i16exps(in) + #define s2exps2(in,size,out) sexpa(in, size[0]*size[1], out) #define d2expd2(in,size,out) dexpa(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2expz2(in,size,out) zexpa(in, size[0]*size[1], out) +#define u82exps2(in,size,out) u8expa(in, size[0]*size[1], out) + +#define i82exps2(in,size,out) i8expa(in, size[0]*size[1], out) + +#define u162exps2(in,size,out) u16expa(in, size[0]*size[1], out) + +#define i162exps2(in,size,out) i16expa(in, size[0]*size[1], out) + #endif /* !__INT_EXP_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_int16.h b/src/c/elementaryFunctions/interfaces/int_int16.h index 353890d..a5d6610 100644 --- a/src/c/elementaryFunctions/interfaces/int_int16.h +++ b/src/c/elementaryFunctions/interfaces/int_int16.h @@ -19,8 +19,20 @@ #define d0int16i160(in) dint16s(in) +#define u80int16i160(in) u8int16s(in) + +#define i80int16i160(in) i8int16s(in) + +#define u160int16i160(in) u16int16s(in) + #define s2int16i162(in,size,out) sint16a(in, size[0]*size[1], out) #define d2int16i162(in,size,out) dint16a(in, size[0]*size[1], out) +#define u82int16i162(in,size,out) u8int16a(in, size[0]*size[1], out) + +#define i82int16i162(in,size,out) i8int16a(in, size[0]*size[1], out) + +#define u162int16i162(in,size,out) u16int16a(in, size[0]*size[1], out) + #endif /* !__INT_INT8_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_int8.h b/src/c/elementaryFunctions/interfaces/int_int8.h index 0f6dde2..9a50e01 100644 --- a/src/c/elementaryFunctions/interfaces/int_int8.h +++ b/src/c/elementaryFunctions/interfaces/int_int8.h @@ -19,8 +19,20 @@ #define d0int8i80(in) dint8s(in) +#define u80int8i80(in) u8int8s(in) + +#define u160int8i80(in) u16int8s(in) + +#define i160int8i80(in) i16int8s(in) + #define s2int8i82(in,size,out) sint8a(in, size[0]*size[1], out) #define d2int8i82(in,size,out) dint8a(in, size[0]*size[1], out) +#define u82int8i82(in,size,out) u8int8a(in, size[0]*size[1], out) + +#define u162int8i82(in,size,out) u16int8a(in, size[0]*size[1], out) + +#define i162int8i82(in,size,out) i16int8a(in, size[0]*size[1], out) + #endif /* !__INT_INT8_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_sin.h b/src/c/elementaryFunctions/interfaces/int_sin.h index 556281a..4132704 100644 --- a/src/c/elementaryFunctions/interfaces/int_sin.h +++ b/src/c/elementaryFunctions/interfaces/int_sin.h @@ -23,6 +23,14 @@ #define z0sinz0(in) zsins(in) +#define u80sins0(in) u8sins(in) + +#define i80sins0(in) i8sins(in) + +#define u160sins0(in) u16sins(in) + +#define i160sins0(in) i16sins(in) + #define s2sins2(in,size,out) ssina(in, size[0]*size[1], out) #define d2sind2(in,size,out) dsina(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2sinz2(in,size,out) zsina(in, size[0]*size[1], out) +#define u82sins2(in,size,out) u8sina(in, size[0]*size[1], out) + +#define i82sins2(in,size,out) i8sina(in, size[0]*size[1], out) + +#define u162sins2(in,size,out) u16sina(in, size[0]*size[1], out) + +#define i162sins2(in,size,out) i16sina(in, size[0]*size[1], out) + #endif /* !__INT_SIN_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_sinh.h b/src/c/elementaryFunctions/interfaces/int_sinh.h index e0c930e..c5682a4 100644 --- a/src/c/elementaryFunctions/interfaces/int_sinh.h +++ b/src/c/elementaryFunctions/interfaces/int_sinh.h @@ -23,6 +23,14 @@ #define z0sinhz0(in) zsinhs(in) +#define u80sinhs0(in) u8sinhs(in) + +#define i80sinhs0(in) i8sinhs(in) + +#define u160sinhs0(in) u16sinhs(in) + +#define i160sinhs0(in) i16sinhs(in) + #define s2sinhs2(in,size,out) ssinha(in, size[0]*size[1], out) #define d2sinhd2(in,size,out) dsinha(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2sinhz2(in,size,out) zsinha(in, size[0]*size[1], out) +#define u82sinhs2(in,size,out) u8sinha(in, size[0]*size[1], out) + +#define i82sinhs2(in,size,out) i8sinha(in, size[0]*size[1], out) + +#define u162sinhs2(in,size,out) u16sinha(in, size[0]*size[1], out) + +#define i162sinhs2(in,size,out) i16sinha(in, size[0]*size[1], out) + #endif /* !__INT_SINH_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_tan.h b/src/c/elementaryFunctions/interfaces/int_tan.h index c2c3df2..ddfb4ca 100644 --- a/src/c/elementaryFunctions/interfaces/int_tan.h +++ b/src/c/elementaryFunctions/interfaces/int_tan.h @@ -23,6 +23,14 @@ #define z0tanz0(in) ztans(in) +#define u80tans0(in) u8tans(in) + +#define i80tans0(in) i8tans(in) + +#define u160tans0(in) u16tans(in) + +#define i160tans0(in) i16tans(in) + #define s2tans2(in,size,out) stana(in, size[0]*size[1], out) #define d2tand2(in,size,out) dtana(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2tanz2(in,size,out) ztana(in, size[0]*size[1], out) +#define u82tans2(in,size,out) u8tana(in, size[0]*size[1], out) + +#define i82tans2(in,size,out) i8tana(in, size[0]*size[1], out) + +#define u162tans2(in,size,out) u16tana(in, size[0]*size[1], out) + +#define i162tans2(in,size,out) i16tana(in, size[0]*size[1], out) + #endif /* !__INT_TAN_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_tanh.h b/src/c/elementaryFunctions/interfaces/int_tanh.h index 1819d3a..e60e2c2 100644 --- a/src/c/elementaryFunctions/interfaces/int_tanh.h +++ b/src/c/elementaryFunctions/interfaces/int_tanh.h @@ -23,6 +23,14 @@ #define z0tanhz0(in) ztanhs(in) +#define u80tanhs0(in) u8tanhs(in) + +#define i80tanhs0(in) i8tanhs(in) + +#define u160tanhs0(in) u16tanhs(in) + +#define i160tanhs0(in) i16tanhs(in) + #define s2tanhs2(in,size,out) stanha(in, size[0]*size[1], out) #define d2tanhd2(in,size,out) dtanha(in, size[0]*size[1], out) @@ -31,4 +39,12 @@ #define z2tanhz2(in,size,out) ztanha(in, size[0]*size[1], out) +#define u82tanhs2(in,size,out) u8tanha(in, size[0]*size[1], out) + +#define i82tanhs2(in,size,out) i8tanha(in, size[0]*size[1], out) + +#define u162tanhs2(in,size,out) u16tanha(in, size[0]*size[1], out) + +#define i162tanhs2(in,size,out) i16tanha(in, size[0]*size[1], out) + #endif /* !__INT_TANH_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_uint16.h b/src/c/elementaryFunctions/interfaces/int_uint16.h index 7d36243..6d69caf 100644 --- a/src/c/elementaryFunctions/interfaces/int_uint16.h +++ b/src/c/elementaryFunctions/interfaces/int_uint16.h @@ -19,8 +19,20 @@ #define d0uint16u160(in) duint16s(in) +#define u80uint16u160(in) u8uint16s(in) + +#define i80uint16u160(in) i8uint16s(in) + +#define i160uint16u160(in) i16uint16s(in) + #define s2uint16u162(in,size,out) suint16a(in, size[0]*size[1], out) #define d2uint16u162(in,size,out) duint16a(in, size[0]*size[1], out) +#define u82uint16u162(in,size,out) u8uint16a(in, size[0]*size[1], out) + +#define i82uint16u162(in,size,out) i8int16a(in, size[0]*size[1], out) + +#define i162uint16u162(in,size,out) i16uint16a(in, size[0]*size[1], out) + #endif /* !__INT_UINT8_H__ */ diff --git a/src/c/elementaryFunctions/interfaces/int_uint8.h b/src/c/elementaryFunctions/interfaces/int_uint8.h index d12b275..b29d7bb 100644 --- a/src/c/elementaryFunctions/interfaces/int_uint8.h +++ b/src/c/elementaryFunctions/interfaces/int_uint8.h @@ -19,8 +19,20 @@ #define d0uint8u80(in) duint8s(in) +#define i80uint8u80(in) i8uint8s(in) + +#define u160uint8u80(in) u16uint8s(in) + +#define i160uint8u80(in) i16uint8s(in) + #define s2uint8u82(in,size,out) suint8a(in, size[0]*size[1], out) #define d2uint8u82(in,size,out) duint8a(in, size[0]*size[1], out) +#define i82uint8u82(in,size,out) i8uint8a(in, size[0]*size[1], out) + +#define u162uint8u82(in,size,out) u16uint8a(in, size[0]*size[1], out) + +#define i162uint8u82(in,size,out) i16uint8a(in, size[0]*size[1], out) + #endif /* !__INT_UINT8_H__ */ diff --git a/src/c/elementaryFunctions/sin/i16sina.c b/src/c/elementaryFunctions/sin/i16sina.c new file mode 100644 index 0000000..0a00146 --- /dev/null +++ b/src/c/elementaryFunctions/sin/i16sina.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sin.h" + +void i16sina(int16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i16sins(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sin/i16sins.c b/src/c/elementaryFunctions/sin/i16sins.c new file mode 100644 index 0000000..cbf69d6 --- /dev/null +++ b/src/c/elementaryFunctions/sin/i16sins.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sin.h" + +float i16sins(int16 x) { + return (sin(x)); +} diff --git a/src/c/elementaryFunctions/sin/i8sina.c b/src/c/elementaryFunctions/sin/i8sina.c new file mode 100644 index 0000000..f811501 --- /dev/null +++ b/src/c/elementaryFunctions/sin/i8sina.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sin.h" + +void i8sina(int8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i8sins(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sin/i8sins.c b/src/c/elementaryFunctions/sin/i8sins.c new file mode 100644 index 0000000..ab522ef --- /dev/null +++ b/src/c/elementaryFunctions/sin/i8sins.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sin.h" + +float i8sins(int8 x) { + return (sin(x)); +} diff --git a/src/c/elementaryFunctions/sin/u16sina.c b/src/c/elementaryFunctions/sin/u16sina.c new file mode 100644 index 0000000..fa4645f --- /dev/null +++ b/src/c/elementaryFunctions/sin/u16sina.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sin.h" + +void u16sina(uint16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u16sins(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sin/u16sins.c b/src/c/elementaryFunctions/sin/u16sins.c new file mode 100644 index 0000000..dfa215d --- /dev/null +++ b/src/c/elementaryFunctions/sin/u16sins.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sin.h" + +float u16sins(uint16 x) { + return (sin(x)); +} diff --git a/src/c/elementaryFunctions/sin/u8sina.c b/src/c/elementaryFunctions/sin/u8sina.c new file mode 100644 index 0000000..2bfe866 --- /dev/null +++ b/src/c/elementaryFunctions/sin/u8sina.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sin.h" + +void u8sina(uint8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u8sins(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sin/u8sins.c b/src/c/elementaryFunctions/sin/u8sins.c new file mode 100644 index 0000000..b1d3179 --- /dev/null +++ b/src/c/elementaryFunctions/sin/u8sins.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sin.h" + +float u8sins(uint8 x) { + return (sin(x)); +} diff --git a/src/c/elementaryFunctions/sinh/i16sinha.c b/src/c/elementaryFunctions/sinh/i16sinha.c new file mode 100644 index 0000000..107d999 --- /dev/null +++ b/src/c/elementaryFunctions/sinh/i16sinha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sinh.h" + +void i16sinha(int16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i16sinhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sinh/i16sinhs.c b/src/c/elementaryFunctions/sinh/i16sinhs.c new file mode 100644 index 0000000..ade1d6f --- /dev/null +++ b/src/c/elementaryFunctions/sinh/i16sinhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sinh.h" + +float i16sinhs(int16 x) { + return (sinh(x)); +} diff --git a/src/c/elementaryFunctions/sinh/i8sinha.c b/src/c/elementaryFunctions/sinh/i8sinha.c new file mode 100644 index 0000000..e5fe6e4 --- /dev/null +++ b/src/c/elementaryFunctions/sinh/i8sinha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sinh.h" + +void i8sinha(int8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i8sinhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sinh/i8sinhs.c b/src/c/elementaryFunctions/sinh/i8sinhs.c new file mode 100644 index 0000000..69bf5ba --- /dev/null +++ b/src/c/elementaryFunctions/sinh/i8sinhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sinh.h" + +float i8sinhs(int8 x) { + return (sinh(x)); +} diff --git a/src/c/elementaryFunctions/sinh/u16sinha.c b/src/c/elementaryFunctions/sinh/u16sinha.c new file mode 100644 index 0000000..56eb1f8 --- /dev/null +++ b/src/c/elementaryFunctions/sinh/u16sinha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sinh.h" + +void u16sinha(uint16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u16sinhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sinh/u16sinhs.c b/src/c/elementaryFunctions/sinh/u16sinhs.c new file mode 100644 index 0000000..e9daf00 --- /dev/null +++ b/src/c/elementaryFunctions/sinh/u16sinhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sinh.h" + +float u16sinhs(uint16 x) { + return (sinh(x)); +} diff --git a/src/c/elementaryFunctions/sinh/u8sinha.c b/src/c/elementaryFunctions/sinh/u8sinha.c new file mode 100644 index 0000000..b1e2dfe --- /dev/null +++ b/src/c/elementaryFunctions/sinh/u8sinha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "sinh.h" + +void u8sinha(uint8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u8sinhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/sinh/u8sinhs.c b/src/c/elementaryFunctions/sinh/u8sinhs.c new file mode 100644 index 0000000..126f01c --- /dev/null +++ b/src/c/elementaryFunctions/sinh/u8sinhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "sinh.h" + +float u8sinhs(uint8 x) { + return (sinh(x)); +} diff --git a/src/c/elementaryFunctions/tan/i16tana.c b/src/c/elementaryFunctions/tan/i16tana.c new file mode 100644 index 0000000..cf1ed94 --- /dev/null +++ b/src/c/elementaryFunctions/tan/i16tana.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tan.h" + +void i16tana(int16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i16tans(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tan/i16tans.c b/src/c/elementaryFunctions/tan/i16tans.c new file mode 100644 index 0000000..61c25d7 --- /dev/null +++ b/src/c/elementaryFunctions/tan/i16tans.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tan.h" + +float i16tans(int16 x) { + return (tanf(x)); +} diff --git a/src/c/elementaryFunctions/tan/i8tana.c b/src/c/elementaryFunctions/tan/i8tana.c new file mode 100644 index 0000000..3312a27 --- /dev/null +++ b/src/c/elementaryFunctions/tan/i8tana.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tan.h" + +void i8tana(int8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i8tans(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tan/i8tans.c b/src/c/elementaryFunctions/tan/i8tans.c new file mode 100644 index 0000000..a7247a6 --- /dev/null +++ b/src/c/elementaryFunctions/tan/i8tans.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tan.h" + +float i8tans(int8 x) { + return (tanf(x)); +} diff --git a/src/c/elementaryFunctions/tan/u16tana.c b/src/c/elementaryFunctions/tan/u16tana.c new file mode 100644 index 0000000..44e7025 --- /dev/null +++ b/src/c/elementaryFunctions/tan/u16tana.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tan.h" + +void u16tana(uint16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u16tans(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tan/u16tans.c b/src/c/elementaryFunctions/tan/u16tans.c new file mode 100644 index 0000000..22f6871 --- /dev/null +++ b/src/c/elementaryFunctions/tan/u16tans.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tan.h" + +float u16tans(uint16 x) { + return (tanf(x)); +} diff --git a/src/c/elementaryFunctions/tan/u8tana.c b/src/c/elementaryFunctions/tan/u8tana.c new file mode 100644 index 0000000..725dfb3 --- /dev/null +++ b/src/c/elementaryFunctions/tan/u8tana.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tan.h" + +void u8tana(uint8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u8tans(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tan/u8tans.c b/src/c/elementaryFunctions/tan/u8tans.c new file mode 100644 index 0000000..7af4ba2 --- /dev/null +++ b/src/c/elementaryFunctions/tan/u8tans.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tan.h" + +float u8tans(uint8 x) { + return (tanf(x)); +} diff --git a/src/c/elementaryFunctions/tanh/i16tanha.c b/src/c/elementaryFunctions/tanh/i16tanha.c new file mode 100644 index 0000000..5c564d9 --- /dev/null +++ b/src/c/elementaryFunctions/tanh/i16tanha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tanh.h" + +void i16tanha(int16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i16tanhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tanh/i16tanhs.c b/src/c/elementaryFunctions/tanh/i16tanhs.c new file mode 100644 index 0000000..d42b267 --- /dev/null +++ b/src/c/elementaryFunctions/tanh/i16tanhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tanh.h" + +float i16tanhs(int16 x) { + return (tanhf(x)); +} diff --git a/src/c/elementaryFunctions/tanh/i8tanha.c b/src/c/elementaryFunctions/tanh/i8tanha.c new file mode 100644 index 0000000..cbcc651 --- /dev/null +++ b/src/c/elementaryFunctions/tanh/i8tanha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tanh.h" + +void i8tanha(int8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = i8tanhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tanh/i8tanhs.c b/src/c/elementaryFunctions/tanh/i8tanhs.c new file mode 100644 index 0000000..569eeaa --- /dev/null +++ b/src/c/elementaryFunctions/tanh/i8tanhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tanh.h" + +float i8tanhs(int8 x) { + return (tanhf(x)); +} diff --git a/src/c/elementaryFunctions/tanh/u16tanha.c b/src/c/elementaryFunctions/tanh/u16tanha.c new file mode 100644 index 0000000..c7aaca4 --- /dev/null +++ b/src/c/elementaryFunctions/tanh/u16tanha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tanh.h" + +void u16tanha(uint16* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u16tanhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tanh/u16tanhs.c b/src/c/elementaryFunctions/tanh/u16tanhs.c new file mode 100644 index 0000000..6ce5efc --- /dev/null +++ b/src/c/elementaryFunctions/tanh/u16tanhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tanh.h" + +float u16tanhs(uint16 x) { + return (tanhf(x)); +} diff --git a/src/c/elementaryFunctions/tanh/u8tanha.c b/src/c/elementaryFunctions/tanh/u8tanha.c new file mode 100644 index 0000000..92f19a6 --- /dev/null +++ b/src/c/elementaryFunctions/tanh/u8tanha.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2006-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "tanh.h" + +void u8tanha(uint8* x, int size, float* y) { + int i = 0; + for (i = 0; i < size; ++i) { + y[i] = u8tanhs(x[i]); + } +} diff --git a/src/c/elementaryFunctions/tanh/u8tanhs.c b/src/c/elementaryFunctions/tanh/u8tanhs.c new file mode 100644 index 0000000..cac46c7 --- /dev/null +++ b/src/c/elementaryFunctions/tanh/u8tanhs.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <math.h> +#include "tanh.h" + +float u8tanhs(uint8 x) { + return (tanhf(x)); +} diff --git a/src/c/elementaryFunctions/uint16/i16uint16a.c b/src/c/elementaryFunctions/uint16/i16uint16a.c new file mode 100644 index 0000000..aea580c --- /dev/null +++ b/src/c/elementaryFunctions/uint16/i16uint16a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "uint16.h" + +void i16uint16a(int16* x, int size, uint16* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = i16uint16s(x[i]); +} diff --git a/src/c/elementaryFunctions/uint16/i16uint16s.c b/src/c/elementaryFunctions/uint16/i16uint16s.c new file mode 100644 index 0000000..03de75e --- /dev/null +++ b/src/c/elementaryFunctions/uint16/i16uint16s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "uint16.h" + +uint16 i16uint16s(int16 x) { + return (uint16) x; +} diff --git a/src/c/elementaryFunctions/uint16/i8uint16a.c b/src/c/elementaryFunctions/uint16/i8uint16a.c new file mode 100644 index 0000000..05dc213 --- /dev/null +++ b/src/c/elementaryFunctions/uint16/i8uint16a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "uint16.h" + +void i8uint16a(int8* x, int size, uint16* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = i8uint16s(x[i]); +} diff --git a/src/c/elementaryFunctions/uint16/i8uint16s.c b/src/c/elementaryFunctions/uint16/i8uint16s.c new file mode 100644 index 0000000..a808841 --- /dev/null +++ b/src/c/elementaryFunctions/uint16/i8uint16s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "uint16.h" + +uint16 i8uint16s(int8 x) { + return (uint16) x; +} diff --git a/src/c/elementaryFunctions/uint16/u8uint16a.c b/src/c/elementaryFunctions/uint16/u8uint16a.c new file mode 100644 index 0000000..0925c41 --- /dev/null +++ b/src/c/elementaryFunctions/uint16/u8uint16a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "uint16.h" + +void u8uint16a(uint8* x, int size, uint16* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = u8uint16s(x[i]); +} diff --git a/src/c/elementaryFunctions/uint16/u8uint16s.c b/src/c/elementaryFunctions/uint16/u8uint16s.c new file mode 100644 index 0000000..9a4df17 --- /dev/null +++ b/src/c/elementaryFunctions/uint16/u8uint16s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "uint16.h" + +uint16 u8uint16s(uint8 x) { + return (uint16) x; +} diff --git a/src/c/elementaryFunctions/uint8/i16uint8a.c b/src/c/elementaryFunctions/uint8/i16uint8a.c new file mode 100644 index 0000000..9cfdcf8 --- /dev/null +++ b/src/c/elementaryFunctions/uint8/i16uint8a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "uint8.h" + +void i16uint8a(int16* x, int size, uint8* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = i16uint8s(x[i]); +} diff --git a/src/c/elementaryFunctions/uint8/i16uint8s.c b/src/c/elementaryFunctions/uint8/i16uint8s.c new file mode 100644 index 0000000..9b84d70 --- /dev/null +++ b/src/c/elementaryFunctions/uint8/i16uint8s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "uint8.h" + +uint8 i16uint8s(int16 x) { + return (uint8) x; +} diff --git a/src/c/elementaryFunctions/uint8/i8uint8a.c b/src/c/elementaryFunctions/uint8/i8uint8a.c new file mode 100644 index 0000000..34c65d1 --- /dev/null +++ b/src/c/elementaryFunctions/uint8/i8uint8a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "uint8.h" + +void i8uint8a(int8* x, int size, uint8* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = i8uint8s(x[i]); +} diff --git a/src/c/elementaryFunctions/uint8/i8uint8s.c b/src/c/elementaryFunctions/uint8/i8uint8s.c new file mode 100644 index 0000000..0f57a50 --- /dev/null +++ b/src/c/elementaryFunctions/uint8/i8uint8s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "uint8.h" + +uint8 i8uint8s(int8 x) { + return (uint8) x; +} diff --git a/src/c/elementaryFunctions/uint8/u16uint8a.c b/src/c/elementaryFunctions/uint8/u16uint8a.c new file mode 100644 index 0000000..bfb2499 --- /dev/null +++ b/src/c/elementaryFunctions/uint8/u16uint8a.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "uint8.h" + +void u16uint8a(uint16* x, int size, uint8* out) { + int i = 0; + for (i=0;i<size;i++) out[i] = u16uint8s(x[i]); +} diff --git a/src/c/elementaryFunctions/uint8/u16uint8s.c b/src/c/elementaryFunctions/uint8/u16uint8s.c new file mode 100644 index 0000000..be883eb --- /dev/null +++ b/src/c/elementaryFunctions/uint8/u16uint8s.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud Torset + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "uint8.h" + +uint8 u16uint8s(uint16 x) { + return (uint8) x; +} diff --git a/src/c/matrixOperations/eye/i16eyea.c b/src/c/matrixOperations/eye/i16eyea.c new file mode 100644 index 0000000..90d7fe7 --- /dev/null +++ b/src/c/matrixOperations/eye/i16eyea.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "eye.h" + +void i16eyea(int16* in, int _iRows, int _iCols) +{ + int i, j ; + + for ( i = 0 ; i < _iCols ; i++ ) + for ( j = 0 ; j < _iRows ; j++ ) + in[i*_iRows + j] = (i == j)?(int16)1:(int16)0 ; +} + diff --git a/src/c/matrixOperations/eye/i8eyea.c b/src/c/matrixOperations/eye/i8eyea.c new file mode 100644 index 0000000..e2fecca --- /dev/null +++ b/src/c/matrixOperations/eye/i8eyea.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "eye.h" + +void i8eyea(int8* in, int _iRows, int _iCols) +{ + int i, j ; + + for ( i = 0 ; i < _iCols ; i++ ) + for ( j = 0 ; j < _iRows ; j++ ) + in[i*_iRows + j] = (i == j)?(int8)1:(int8)0 ; +} + diff --git a/src/c/matrixOperations/eye/u16eyea.c b/src/c/matrixOperations/eye/u16eyea.c new file mode 100644 index 0000000..63c479f --- /dev/null +++ b/src/c/matrixOperations/eye/u16eyea.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "eye.h" + +void u16eyea(uint16* in, int _iRows, int _iCols) +{ + int i, j ; + + for ( i = 0 ; i < _iCols ; i++ ) + for ( j = 0 ; j < _iRows ; j++ ) + in[i*_iRows + j] = (i == j)?(uint16)1:(uint16)0 ; +} + diff --git a/src/c/matrixOperations/eye/u8eyea.c b/src/c/matrixOperations/eye/u8eyea.c new file mode 100644 index 0000000..8278303 --- /dev/null +++ b/src/c/matrixOperations/eye/u8eyea.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "eye.h" + +void u8eyea(uint8* in, int _iRows, int _iCols) +{ + int i, j ; + + for ( i = 0 ; i < _iCols ; i++ ) + for ( j = 0 ; j < _iRows ; j++ ) + in[i*_iRows + j] = (i == j)?(uint8)1:(uint8)0 ; +} + diff --git a/src/c/matrixOperations/includes/eye.h b/src/c/matrixOperations/includes/eye.h index f7f2ef2..95bdd79 100644 --- a/src/c/matrixOperations/includes/eye.h +++ b/src/c/matrixOperations/includes/eye.h @@ -16,6 +16,7 @@ #include "dynlib_matrixoperations.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "ones.h" #ifdef __cplusplus extern "C" { @@ -42,6 +43,26 @@ extern "C" { #define zeyes(in) DoubleComplex(1, 0) /* +** \brief create a Uint8 Eye value +*/ +#define u8eyes(in) (uint8)1 + +/* +** \brief create a int8 Eye value +*/ +#define i8eyes(in) (int8)1 + +/* +** \brief create a Uint16 Eye value +*/ +#define u16eyes(in) (uint16)1 + +/* +** \brief create a int16 Eye value +*/ +#define i16eyes(in) (int16)1 + +/* ** \brief create a float Eye matrix */ EXTERN_MATOPS void seyea(float* in, int _iRows, int _iCols); @@ -61,6 +82,26 @@ EXTERN_MATOPS void ceyea(floatComplex* in, int _iRows, int _iCols); */ EXTERN_MATOPS void zeyea(doubleComplex* in, int _iRows, int _iCols); +/* +** \brief create a uint8 Eye matrix +*/ +EXTERN_MATOPS void u8eyea(uint8* in, int _iRows, int _iCols); + +/* +** \brief create a int8 Eye matrix +*/ +EXTERN_MATOPS void i8eyea(int8* in, int _iRows, int _iCols); + +/* +** \brief create a uint16 Eye matrix +*/ +EXTERN_MATOPS void u16eyea(uint16* in, int _iRows, int _iCols); + +/* +** \brief create a int16 Eye matrix +*/ +EXTERN_MATOPS void i16eyea(int16* in, int _iRows, int _iCols); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/matrixOperations/includes/matrixInversion.h b/src/c/matrixOperations/includes/matrixInversion.h index 9031245..e547bb9 100644 --- a/src/c/matrixOperations/includes/matrixInversion.h +++ b/src/c/matrixOperations/includes/matrixInversion.h @@ -16,6 +16,7 @@ #include "abs.h" #include "dynlib_matrixoperations.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -59,6 +60,43 @@ EXTERN_MATOPS void cinverma ( floatComplex* in, floatComplex* out, int leadDimIn EXTERN_MATOPS void zinverma ( doubleComplex* in, doubleComplex* out, int leadDimIn ); +/* +** \brief Compute the matrix inverse for uint8. +** \param in : input matrix. +** \param leadDimIn : the leading dimension of the matrix . +** \param out : the matrix inverse of the input . +*/ + +EXTERN_MATOPS void u8inverma ( uint8* in, float* out, int leadDimIn ); + +/* +** \brief Compute the matrix inverse for int8. +** \param in : input matrix. +** \param leadDimIn : the leading dimension of the matrix . +** \param out : the matrix inverse of the input . +*/ + +EXTERN_MATOPS void i8inverma ( int8* in, float* out, int leadDimIn ); + +/* +** \brief Compute the matrix inverse for uint16. +** \param in : input matrix. +** \param leadDimIn : the leading dimension of the matrix . +** \param out : the matrix inverse of the input . +*/ + +EXTERN_MATOPS void u16inverma ( uint16* in, float* out, int leadDimIn ); + +/* +** \brief Compute the matrix inverse for int16. +** \param in : input matrix. +** \param leadDimIn : the leading dimension of the matrix . +** \param out : the matrix inverse of the input . +*/ + +EXTERN_MATOPS void i16inverma ( int16* in, float* out, int leadDimIn ); + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/matrixOperations/includes/ones.h b/src/c/matrixOperations/includes/ones.h index 63d8bd4..6734017 100644 --- a/src/c/matrixOperations/includes/ones.h +++ b/src/c/matrixOperations/includes/ones.h @@ -17,6 +17,7 @@ #include "dynlib_matrixoperations.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus @@ -43,25 +44,67 @@ extern "C" { */ #define zoness(in) DoubleComplex(1, 0) +/* +** \brief create a uint8 one value +*/ +#define u8oness(in) (uint8)1 + +/* +** \brief create a int8 one value +*/ +#define i8oness(in) (int8)1 + +/* +** \brief create a uint16 one value +*/ +#define u16oness(in) (uint16)1 + +/* +** \brief create a int16 one value +*/ +#define i16oness(in) (int16)1 /* ** \brief create a float matrix full of one */ EXTERN_MATOPS void sonesa ( float* in , int rows , int cols ); + /* ** \brief create a float complex matrix full of one */ EXTERN_MATOPS void conesa ( floatComplex* in , int rows ,int cols ); + /* ** \brief create a double matrix full of one */ EXTERN_MATOPS void donesa ( double* in , int rows ,int cols ); + /* ** \brief create a double complex matrix full of one */ EXTERN_MATOPS void zonesa ( doubleComplex* in , int rows ,int cols ); +/* +** \brief create a uint8 matrix full of one +*/ +EXTERN_MATOPS void u8onesa ( uint8* in , int rows , int cols ); + +/* +** \brief create a int8 matrix full of one +*/ +EXTERN_MATOPS void i8onesa ( int8* in , int rows , int cols ); + +/* +** \brief create a uint16 matrix full of one +*/ +EXTERN_MATOPS void u16onesa ( uint16* in , int rows , int cols ); + +/* +** \brief create a int16 matrix full of one +*/ +EXTERN_MATOPS void i16onesa ( int16* in , int rows , int cols ); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/matrixOperations/includes/zeros.h b/src/c/matrixOperations/includes/zeros.h index 06b2e5a..993940f 100644 --- a/src/c/matrixOperations/includes/zeros.h +++ b/src/c/matrixOperations/includes/zeros.h @@ -17,6 +17,7 @@ #include "dynlib_matrixoperations.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -43,6 +44,25 @@ extern "C" { #define zzeross(in) DoubleComplex(0, 0) +/* +** \brief create a single uint8 zero +*/ +#define u8zerosu8(in) (uint8)0 + +/* +** \brief create a single int8 zero +*/ +#define i8zerosi8(in) (int8)0 + +/* +** \brief create a single uint8 zero +*/ +#define u16zerosu16(in) (uint16)0 + +/* +** \brief create a single int8 zero +*/ +#define i16zerosi16(in) (int16)0 /* ** \brief create a float matrix full of one @@ -66,6 +86,26 @@ EXTERN_MATOPS void zzerosa ( doubleComplex* in , int rows ,int cols ); */ EXTERN_MATOPS void dzerosh ( double* in , int rows ,int cols , int levels); +/* +** \brief create a uint8 matrix full of zero +*/ +EXTERN_MATOPS void u8zerosa ( uint8* in , int rows , int cols ); + +/* +** \brief create a int8 matrix full of zero +*/ +EXTERN_MATOPS void i8zerosa ( int8* in , int rows , int cols ); + +/* +** \brief create a uint16 matrix full of zero +*/ +EXTERN_MATOPS void u16zerosa ( uint16* in , int rows , int cols ); + +/* +** \brief create a int16 matrix full of zero +*/ +EXTERN_MATOPS void i16zerosa ( int16* in , int rows , int cols ); + #ifdef __cplusplus } /* extern "C" */ diff --git a/src/c/matrixOperations/interfaces/int_eye.h b/src/c/matrixOperations/interfaces/int_eye.h index 81ed7fd..1e10eb8 100644 --- a/src/c/matrixOperations/interfaces/int_eye.h +++ b/src/c/matrixOperations/interfaces/int_eye.h @@ -20,7 +20,13 @@ #define eyed0() 1 +#define eyeu80() (uint8)1 +#define eyei80() (int8)1 + +#define eyeu160() (uint16)1 + +#define eyei160() (int16)1 #define s0eyes0(in) seyes(in) @@ -30,16 +36,37 @@ #define z0eyez0(in) zeyes(in) +#define u80eyeu80(in) u8eyes(in) + +#define i80eyei80(in) i8eyes(in) + +#define u160eyeu160(in) u16eyes(in) + +#define i160eyei160(in) i16eyes(in) #define s0s0eyes0(in1,in2) 1.0f #define d0d0eyed0(in,in2) 1 +#define u80u80eyeu80(in1,in2) (uint8)1 + +#define i80i80eyei80(in1,in2) (int8)1 + +#define u160u160eyeu160(in1,in2) (uint16)1 + +#define i160i160eyei160(in1,in2) (int16)1 #define s0s0eyes2(in1,in2,out) seyea(out, in1, in2) #define d0d0eyed2(in1,in2,out) deyea(out, in1, in2) +#define u80u80eyeu82(in1,in2,out) u8eyea(out, in1, in2) + +#define i80i80eyei82(in1,in2,out) i8eyea(out, in1, in2) + +#define u160u160eyeu162(in1,in2,out) u16eyea(out, in1, in2) + +#define i160i160eyei162(in1,in2,out) i16eyea(out, in1, in2) #define s2eyes2(in,size,out) seyea(out, size[0], size[1]) @@ -49,5 +76,13 @@ #define z2eyez2(in,size,out) zeyea(out, size[0], size[1]) +#define u82eyeu82(in,size,out) u8eyea(out, size[0], size[1]) + +#define i82eyei82(in,size,out) i8eyea(out, size[0], size[1]) + +#define u162eyeu162(in,size,out) u16eyea(out, size[0], size[1]) + +#define i162eyei162(in,size,out) i16eyea(out, size[0], size[1]) + #endif /* !__INT_EYE_H__ */ diff --git a/src/c/matrixOperations/interfaces/int_invert.h b/src/c/matrixOperations/interfaces/int_invert.h index d31481b..285a0f4 100644 --- a/src/c/matrixOperations/interfaces/int_invert.h +++ b/src/c/matrixOperations/interfaces/int_invert.h @@ -23,6 +23,14 @@ #define z0invz0(in) zrdivs(DoubleComplex(1,0),in) +#define u80invs0(in) 1.0f/(float)in + +#define i80invs0(in) 1.0f/(float)in + +#define u160invs0(in) 1.0f/(float)in + +#define i160invs0(in) 1.0f/(float)in + #define s2invs2(in,size,out) sinverma(in, out, size[0]) #define d2invd2(in,size,out) dinverma(in, out, size[0]) @@ -31,4 +39,12 @@ #define z2invz2(in,size,out) zinverma(in, out, size[0]) +#define u82invs2(in,size,out) u8inverma(in, out, size[0]) + +#define i82invs2(in,size,out) i8inverma(in, out, size[0]) + +#define u162invs2(in,size,out) u16inverma(in, out, size[0]) + +#define i162invs2(in,size,out) i16inverma(in, out, size[0]) + #endif /* !__INT_INV_H__ */ diff --git a/src/c/matrixOperations/interfaces/int_ones.h b/src/c/matrixOperations/interfaces/int_ones.h index 0259b4c..3946a48 100644 --- a/src/c/matrixOperations/interfaces/int_ones.h +++ b/src/c/matrixOperations/interfaces/int_ones.h @@ -20,7 +20,13 @@ #define onesd0() 1 +#define onesu80() (uint8)1 +#define onesi80() (int8)1 + +#define onesu160() (uint16)1 + +#define onesi160() (int16)1 #define s0oness0(in) soness(in) @@ -30,16 +36,37 @@ #define z0onesz0(in) zoness(in) +#define u80onesu80(in) u8oness(in) + +#define i80onesi80(in) i8oness(in) + +#define u160onesu160(in) u16oness(in) + +#define i160onesi160(in) i16oness(in) #define s0s0oness0(in1,in2) 1.0f #define d0d0onesd0(in,in2) 1 +#define u80u80onesu80(in1,in2) (uint8)1 + +#define i80i80onesi80(in1,in2) (int8)1 + +#define u160u160onesu160(in1,in2) (uint16)1 + +#define i160i160onesi160(in1,in2) (int16)1 #define s0s0oness2(in1,in2,out) sonesa(out, in1, in2) #define d0d0onesd2(in1,in2,out) donesa(out, in1, in2) +#define u80u80onesu82(in1,in2,out) u8onesa(out, in1, in2) + +#define i80i80onesi82(in1,in2,out) i8onesa(out, in1, in2) + +#define u160u160onesu82(in1,in2,out) u16onesa(out, in1, in2) + +#define i160i160onesi162(in1,in2,out) i16onesa(out, in1, in2) #define s2oness2(in,size,out) sonesa(out, size[0], size[1]) @@ -49,5 +76,12 @@ #define z2onesz2(in,size,out) zonesa(out, size[0], size[1]) +#define u82onesu82(in,size,out) u8onesa(out, size[0], size[1]) + +#define i82onesi82(in,size,out) i8onesa(out, size[0], size[1]) + +#define u162onesu162(in,size,out) u16onesa(out, size[0], size[1]) + +#define i162onesi162(in,size,out) i16onesa(out, size[0], size[1]) #endif /* !__INT_ONES_H__ */ diff --git a/src/c/matrixOperations/interfaces/int_zeros.h b/src/c/matrixOperations/interfaces/int_zeros.h index 4bc3213..0f97af0 100644 --- a/src/c/matrixOperations/interfaces/int_zeros.h +++ b/src/c/matrixOperations/interfaces/int_zeros.h @@ -21,7 +21,13 @@ #define zerosd0() 0 +#define zerosu80() (uint8)0 +#define zerosi80() (int8)0 + +#define zerosu160() (uint16)0 + +#define zerosi160() (int16)0 #define s0zeross0(in) szeross(in) @@ -31,16 +37,37 @@ #define z0zerosz0(in) zzeross(in) +#define u80zerosu80(in) u8zeross(in) + +#define i80zerosi80(in) i8zeross(in) + +#define u160zerosu160(in) u16zeross(in) + +#define i160zerosi160(in) i16zeross(in) #define s0s0zeross0(in1,in2) 0.0f -#define d0d0zerosd0(in,in2) 0 +#define d0d0zerosd0(in1,in2) 0 + +#define u80u80zerosu80(in1,in2) (uint8)0 + +#define i80i80zerosi80(in1,in2) (int8)0 + +#define u160u160zerosu160(in1,in2) (uint16)0 +#define i160i160zerosi160(in1,in2) (int16)0 #define s0s0zeross2(in1,in2,out) szerosa(out, in1, in2) #define d0d0zerosd2(in1,in2,out) dzerosa(out, in1, in2) +#define u80u80zeross2(in1,in2,out) u80zerosa(out, in1, in2) + +#define i80i80zeross2(in1,in2,out) i80zerosa(out, in1, in2) + +#define u160u160zeross2(in1,in2,out) u160zerosa(out, in1, in2) + +#define i160i160zeross2(in1,in2,out) i160zerosa(out, in1, in2) #define s2zeross2(in,size,out) szerosa(out, size[0], size[1]) @@ -50,5 +77,13 @@ #define z2zerosz2(in,size,out) zzerosa(out, size[0], size[1]) +#define u82zerosu82(in,size,out) u8zerosa(out, size[0], size[1]) + +#define i82zerosi82(in,size,out) i8zerosa(out, size[0], size[1]) + +#define u162zerosu162(in,size,out) u16zerosa(out, size[0], size[1]) + +#define i162zerosi162(in,size,out) i16zerosa(out, size[0], size[1]) + #define d0d0d0zerosd3(in1, in2, in3, out) dzerosh(out, in1, in2, in3); #endif /* !__INT_ZEROS_H__ */ diff --git a/src/c/matrixOperations/inversion/i16inverma.c b/src/c/matrixOperations/inversion/i16inverma.c new file mode 100644 index 0000000..a6b1c08 --- /dev/null +++ b/src/c/matrixOperations/inversion/i16inverma.c @@ -0,0 +1,55 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include <stdio.h> +#include <stdlib.h> +#include "matrixInversion.h" +#include "lapack.h" + +void i16inverma ( int16* in, float* out, int leadDimIn ) +{ + + int i = 0 ; + /* these 3 variable are created to permit to use the value in the fortran functions + because they need double matrix as arguments and we can't cast directly the pointers + without having problems , i know that's ugly */ + double *dblin = NULL; + double *dblout = NULL; + + + + /* Array allocations*/ + dblin = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + dblout = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + + + + /*copy and cast all the float value into double value */ + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i ++ ) + { + dblin[i] = (double) in[i] ; + } + + dinverma ( dblin, dblout, leadDimIn ); + + + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i++ ) + { + out[i] =(float) dblout[i] ; + + } + + free ( dblin); + free ( dblout); + +} diff --git a/src/c/matrixOperations/inversion/i8inverma.c b/src/c/matrixOperations/inversion/i8inverma.c new file mode 100644 index 0000000..24fb920 --- /dev/null +++ b/src/c/matrixOperations/inversion/i8inverma.c @@ -0,0 +1,55 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include <stdio.h> +#include <stdlib.h> +#include "matrixInversion.h" +#include "lapack.h" + +void i8inverma ( int8* in, float* out, int leadDimIn ) +{ + + int i = 0 ; + /* these 3 variable are created to permit to use the value in the fortran functions + because they need double matrix as arguments and we can't cast directly the pointers + without having problems , i know that's ugly */ + double *dblin = NULL; + double *dblout = NULL; + + + + /* Array allocations*/ + dblin = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + dblout = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + + + + /*copy and cast all the float value into double value */ + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i ++ ) + { + dblin[i] = (double) in[i] ; + } + + dinverma ( dblin, dblout, leadDimIn ); + + + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i++ ) + { + out[i] =(float) dblout[i] ; + + } + + free ( dblin); + free ( dblout); + +} diff --git a/src/c/matrixOperations/inversion/u16inverma.c b/src/c/matrixOperations/inversion/u16inverma.c new file mode 100644 index 0000000..a27182d --- /dev/null +++ b/src/c/matrixOperations/inversion/u16inverma.c @@ -0,0 +1,55 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include <stdio.h> +#include <stdlib.h> +#include "matrixInversion.h" +#include "lapack.h" + +void u16inverma ( uint16* in, float* out, int leadDimIn ) +{ + + int i = 0 ; + /* these 3 variable are created to permit to use the value in the fortran functions + because they need double matrix as arguments and we can't cast directly the pointers + without having problems , i know that's ugly */ + double *dblin = NULL; + double *dblout = NULL; + + + + /* Array allocations*/ + dblin = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + dblout = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + + + + /*copy and cast all the float value into double value */ + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i ++ ) + { + dblin[i] = (double) in[i] ; + } + + dinverma ( dblin, dblout, leadDimIn ); + + + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i++ ) + { + out[i] =(float) dblout[i] ; + + } + + free ( dblin); + free ( dblout); + +} diff --git a/src/c/matrixOperations/inversion/u8inverma.c b/src/c/matrixOperations/inversion/u8inverma.c new file mode 100644 index 0000000..4e8a97c --- /dev/null +++ b/src/c/matrixOperations/inversion/u8inverma.c @@ -0,0 +1,55 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include <stdio.h> +#include <stdlib.h> +#include "matrixInversion.h" +#include "lapack.h" + +void u8inverma ( uint8* in, float* out, int leadDimIn ) +{ + + int i = 0 ; + /* these 3 variable are created to permit to use the value in the fortran functions + because they need double matrix as arguments and we can't cast directly the pointers + without having problems , i know that's ugly */ + double *dblin = NULL; + double *dblout = NULL; + + + + /* Array allocations*/ + dblin = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + dblout = (double*)malloc(sizeof(double) * (unsigned int)(leadDimIn * leadDimIn)); + + + + /*copy and cast all the float value into double value */ + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i ++ ) + { + dblin[i] = (double) in[i] ; + } + + dinverma ( dblin, dblout, leadDimIn ); + + + for ( i = 0 ; i < (leadDimIn * leadDimIn) ; i++ ) + { + out[i] =(float) dblout[i] ; + + } + + free ( dblin); + free ( dblout); + +} diff --git a/src/c/matrixOperations/ones/i16onesa.c b/src/c/matrixOperations/ones/i16onesa.c new file mode 100644 index 0000000..b7949de --- /dev/null +++ b/src/c/matrixOperations/ones/i16onesa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "ones.h" + +void i16onesa ( int16* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (int16)1 ; + + } + +} + + + diff --git a/src/c/matrixOperations/ones/i8onesa.c b/src/c/matrixOperations/ones/i8onesa.c new file mode 100644 index 0000000..7c17912 --- /dev/null +++ b/src/c/matrixOperations/ones/i8onesa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "ones.h" + +void i8onesa ( int8* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (int8)1 ; + + } + +} + + + diff --git a/src/c/matrixOperations/ones/u16onesa.c b/src/c/matrixOperations/ones/u16onesa.c new file mode 100644 index 0000000..852ceef --- /dev/null +++ b/src/c/matrixOperations/ones/u16onesa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "ones.h" + +void u16onesa ( uint16* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (uint16)1 ; + + } + +} + + + diff --git a/src/c/matrixOperations/ones/u8onesa.c b/src/c/matrixOperations/ones/u8onesa.c new file mode 100644 index 0000000..7918a96 --- /dev/null +++ b/src/c/matrixOperations/ones/u8onesa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "ones.h" + +void u8onesa ( uint8* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (uint8)1 ; + + } + +} + + + diff --git a/src/c/matrixOperations/zeros/i16zerosa.c b/src/c/matrixOperations/zeros/i16zerosa.c new file mode 100644 index 0000000..f1ed904 --- /dev/null +++ b/src/c/matrixOperations/zeros/i16zerosa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "zeros.h" + +void i16zerosa ( int16* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (int16)0 ; + + } + +} + + + diff --git a/src/c/matrixOperations/zeros/i8zerosa.c b/src/c/matrixOperations/zeros/i8zerosa.c new file mode 100644 index 0000000..e22e06a --- /dev/null +++ b/src/c/matrixOperations/zeros/i8zerosa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "zeros.h" + +void i8zerosa ( int8* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (int8)0 ; + + } + +} + + + diff --git a/src/c/matrixOperations/zeros/u16zerosa.c b/src/c/matrixOperations/zeros/u16zerosa.c new file mode 100644 index 0000000..6c98d2f --- /dev/null +++ b/src/c/matrixOperations/zeros/u16zerosa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "zeros.h" + +void u16zerosa ( uint16* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (uint16)0 ; + + } + +} + + + diff --git a/src/c/matrixOperations/zeros/u8zerosa.c b/src/c/matrixOperations/zeros/u8zerosa.c new file mode 100644 index 0000000..4203614 --- /dev/null +++ b/src/c/matrixOperations/zeros/u8zerosa.c @@ -0,0 +1,28 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "zeros.h" + +void u8zerosa ( uint8* in , int rows , int cols ) +{ + int i = 0 ; + + for ( i = 0 ; i < rows*cols ; i++) + { + in[i] = (uint8)0 ; + + } + +} + + + diff --git a/src/c/operations/interfaces/int_OpLogNot.h b/src/c/operations/interfaces/int_OpLogNot.h index 6184265..852cd1c 100644 --- a/src/c/operations/interfaces/int_OpLogNot.h +++ b/src/c/operations/interfaces/int_OpLogNot.h @@ -23,6 +23,14 @@ #define z0OpLogNotz0(in) (zreals(in)==0) ? DoubleComplex(1,0) : DoubleComplex(0,0) +#define u8OpLogNotu80(in) (in==0) ? (uint8)1 : (uint8)0 + +#define i8OpLogNoti80(in) (in==0) ? (int8)1 : (int8)0 + +#define u16OpLogNotu160(in) (in==0) ? (uint16)1 : (uint16)0 + +#define i16OpLogNoti160(in) (in==0) ? (int16)1 : (int16)0 + #define s2OpLogNots2(in,size,out) {int i;\ for (i=0;i<size[0]*size[1];i++) out[i]=s0OpLogNots0(in[i]);\ } @@ -39,4 +47,21 @@ for (i=0;i<size[0]*size[1];i++) out[i]=z0OpLogNotz0(in[i]);\ } +#define u82OpLogNotu82(in,size,out) {int i;\ + for (i=0;i<size[0]*size[1];i++) out[i]=u80OpLogNotu80(in[i]);\ + } + +#define i82OpLogNoti82(in,size,out) {int i;\ + for (i=0;i<size[0]*size[1];i++) out[i]=i80OpLogNoti80(in[i]);\ + } + +#define u162OpLogNotu162(in,size,out) {int i;\ + for (i=0;i<size[0]*size[1];i++) out[i]=u160OpLogNoti160(in[i]);\ + } + +#define i162OpLogNoti162(in,size,out) {int i;\ + for (i=0;i<size[0]*size[1];i++) out[i]=i160OpLogNotu160(in[i]);\ + } + + #endif /* !__INT_OPLOGNOT_H__ */ diff --git a/src/c/operations/interfaces/int_OpStar.h b/src/c/operations/interfaces/int_OpStar.h index 53f39e8..f899a29 100644 --- a/src/c/operations/interfaces/int_OpStar.h +++ b/src/c/operations/interfaces/int_OpStar.h @@ -112,7 +112,7 @@ #define u160u162OpStaru162(in1,in2,size,out) {int i=0;\ for (i=0;i<size[0]*size[1];i++) out[i]=in1*in2[i];} -#define i160162OpStari162(in1,in2,size,out) {int i=0;\ +#define i160i162OpStari162(in1,in2,size,out) {int i=0;\ for (i=0;i<size[0]*size[1];i++) out[i]=in1*in2[i];} /* Matrix * Scalar */ @@ -156,7 +156,7 @@ #define u162u160OpStaru162(in1,size,in2,out) {int i=0;\ for (i=0;i<size[0]*size[1];i++) out[i]=in1[i]*in2;} -#define i162160OpStari162(in1,size,in2,out) {int i=0;\ +#define i162i160OpStari162(in1,size,in2,out) {int i=0;\ for (i=0;i<size[0]*size[1];i++) out[i]=in1[i]*in2;} diff --git a/src/c/operations/multiplication/u8mula.c b/src/c/operations/multiplication/u8mula.c new file mode 100644 index 0000000..79d4330 --- /dev/null +++ b/src/c/operations/multiplication/u8mula.c @@ -0,0 +1,21 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Arnaud TORSET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + + +#include "multiplication.h" + +void u8mula(uint8* in1, uint8* in2, int size, uint8* out){ + int i=0; + for (i=0;i<size;i++){ + out[i]=dmuls(in1[i],in2[i]); + } +} diff --git a/src/c/string/disp/i16dispa.c b/src/c/string/disp/i16dispa.c new file mode 100644 index 0000000..a30bd89 --- /dev/null +++ b/src/c/string/disp/i16dispa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double i16dispa (int16* in, int rows, int columns){ + int i = 0,j = 0; + + for (i = 0; i < rows; ++i) { + for (j=0;j<columns;j++) printf (" %d ", in[i+j*rows]); + printf("\n"); + } + return 0; +} diff --git a/src/c/string/disp/i16disps.c b/src/c/string/disp/i16disps.c new file mode 100644 index 0000000..92adab9 --- /dev/null +++ b/src/c/string/disp/i16disps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double i16disps (int16 in) { + printf(" %d \n",in); + return 0; +} diff --git a/src/c/string/disp/i8dispa.c b/src/c/string/disp/i8dispa.c new file mode 100644 index 0000000..467a435 --- /dev/null +++ b/src/c/string/disp/i8dispa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double i8dispa (int8* in, int rows, int columns){ + int i = 0,j = 0; + + for (i = 0; i < rows; ++i) { + for (j=0;j<columns;j++) printf (" %d ", in[i+j*rows]); + printf("\n"); + } + return 0; +} diff --git a/src/c/string/disp/i8disps.c b/src/c/string/disp/i8disps.c new file mode 100644 index 0000000..68b5695 --- /dev/null +++ b/src/c/string/disp/i8disps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double i8disps (int8 in) { + printf(" %d \n",in); + return 0; +} diff --git a/src/c/string/disp/u16dispa.c b/src/c/string/disp/u16dispa.c new file mode 100644 index 0000000..92df9dd --- /dev/null +++ b/src/c/string/disp/u16dispa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double u16dispa (uint16* in, int rows, int columns){ + int i = 0,j = 0; + + for (i = 0; i < rows; ++i) { + for (j=0;j<columns;j++) printf (" %u ", in[i+j*rows]); + printf("\n"); + } + return 0; +} diff --git a/src/c/string/disp/u16disps.c b/src/c/string/disp/u16disps.c new file mode 100644 index 0000000..d27ffb3 --- /dev/null +++ b/src/c/string/disp/u16disps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double u16disps (uint16 in) { + printf(" %u \n",in); + return 0; +} diff --git a/src/c/string/disp/u8dispa.c b/src/c/string/disp/u8dispa.c new file mode 100644 index 0000000..cca8e44 --- /dev/null +++ b/src/c/string/disp/u8dispa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double u8dispa (uint8* in, int rows, int columns){ + int i = 0,j = 0; + + for (i = 0; i < rows; ++i) { + for (j=0;j<columns;j++) printf (" %d ", in[i+j*rows]); + printf("\n"); + } + return 0; +} diff --git a/src/c/string/disp/u8disps.c b/src/c/string/disp/u8disps.c new file mode 100644 index 0000000..78b750a --- /dev/null +++ b/src/c/string/disp/u8disps.c @@ -0,0 +1,18 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "disp.h" + +double u8disps (uint8 in) { + printf(" %d \n",in); + return 0; +} diff --git a/src/c/string/includes/disp.h b/src/c/string/includes/disp.h index 96ccb24..88764f2 100644 --- a/src/c/string/includes/disp.h +++ b/src/c/string/includes/disp.h @@ -19,6 +19,7 @@ #include "dynlib_string.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -44,6 +45,27 @@ EXTERN_STRING double cdisps (floatComplex in); EXTERN_STRING double zdisps (doubleComplex in); /* +** \brief display of a uint8 scalar +*/ +EXTERN_STRING double u8disps (uint8 in); + +/* +** \brief display of a int8 scalar +*/ +EXTERN_STRING double i8disps (int8 in); + +/* +** \brief display of a uint16 scalar +*/ +EXTERN_STRING double u16disps (uint16 in); + +/* +** \brief display of a int16 scalar +*/ +EXTERN_STRING double i16disps (int16 in); + + +/* ** \brief display of a float scalar array ** \param in the float scalar array to display ** \param size the size of the array @@ -71,7 +93,34 @@ EXTERN_STRING double cdispa (floatComplex* in, int rows, int columns); */ EXTERN_STRING double zdispa (doubleComplex* in, int rows, int columns); - +/* +** \brief display of a uint8 scalar array +** \param in the uint8 scalar array to display +** \param size the size of the array +*/ +EXTERN_STRING double u8dispa (uint8* in, int rows, int columns); + +/* +** \brief display of a int8 scalar array +** \param in the int8 scalar array to display +** \param size the size of the array +*/ +EXTERN_STRING double i8dispa (int8* in, int rows, int columns); + +/* +** \brief display of a uint16 scalar array +** \param in the uint16 scalar array to display +** \param size the size of the array +*/ +EXTERN_STRING double u16dispa (uint16* in, int rows, int columns); + +/* +** \brief display of a int16 scalar array +** \param in the int16 scalar array to display +** \param size the size of the array +*/ +EXTERN_STRING double i16dispa (int16* in, int rows, int columns); + EXTERN_STRING double ddisph (double *in, int rows, int cols, int levels); EXTERN_STRING double g2dispd0(char *array,int* tmparraysize); diff --git a/src/c/string/includes/str.h b/src/c/string/includes/str.h index 434c68e..79307b5 100644 --- a/src/c/string/includes/str.h +++ b/src/c/string/includes/str.h @@ -19,6 +19,7 @@ #include "dynlib_string.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -54,6 +55,35 @@ EXTERN_STRING void zstrings (doubleComplex in, char* out); /* +** \brief convert of a uint8 scalar into a char array +** \param in the uint8 scalar to convert +** \param out the output char array +*/ +EXTERN_STRING void u8strings (uint8 in, char* out); + +/* +** \brief convert of a int8 scalar into a char array +** \param in the int8 scalar to convert +** \param out the output char array +*/ +EXTERN_STRING void i8strings (int8 in, char* out); + +/* +** \brief convert of a uint16 scalar into a char array +** \param in the uint16 scalar to convert +** \param out the output char array +*/ +EXTERN_STRING void u16strings (uint16 in, char* out); + +/* +** \brief convert of a int16 scalar into a char array +** \param in the int16 scalar to convert +** \param out the output char array +*/ +EXTERN_STRING void i16strings (int16 in, char* out); + + +/* ** \brief convert of a float scalar array into an array of char arrays ** \param in the float scalar array to convert ** \param out the output array of char arrays @@ -81,6 +111,34 @@ EXTERN_STRING void cstringa (floatComplex* in, int size, char** out ); */ EXTERN_STRING void zstringa (doubleComplex* in, int size, char** out); +/* +** \brief convert of a uint8 scalar array into an array of char arrays +** \param in the uint8 scalar array to convert +** \param out the output array of char arrays +*/ +EXTERN_STRING void u8stringa (uint8* in, int size, char** out); + +/* +** \brief convert of a int8 scalar array into an array of char arrays +** \param in the int8 scalar array to convert +** \param out the output array of char arrays +*/ +EXTERN_STRING void i8stringa (int8* in, int size, char** out); + +/* +** \brief convert of a uint16 scalar array into an array of char arrays +** \param in the uint16 scalar array to convert +** \param out the output array of char arrays +*/ +EXTERN_STRING void u16stringa (uint16* in, int size, char** out); + +/* +** \brief convert of a int16 scalar array into an array of char arrays +** \param in the int16 scalar array to convert +** \param out the output array of char arrays +*/ +EXTERN_STRING void i16stringa (int16* in, int size, char** out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/string/interfaces/int_disp.h b/src/c/string/interfaces/int_disp.h index 57f7bd4..4b6f896 100644 --- a/src/c/string/interfaces/int_disp.h +++ b/src/c/string/interfaces/int_disp.h @@ -25,6 +25,14 @@ #define z0dispd0(in) zdisps(in) +#define u80dispd0(in) u8disps(in) + +#define i80dispd0(in) i8disps(in) + +#define u160dispd0(in) u16disps(in) + +#define i160dispd0(in) i16disps(in) + #define s2dispd0(in,size) sdispa(in,size[0],size[1]) #define d2dispd0(in,size) ddispa(in,size[0],size[1]) @@ -33,6 +41,14 @@ #define z2dispd0(in,size) zdispa(in,size[0],size[1]) +#define u82dispd0(in,size) u8dispa(in,size[0],size[1]) + +#define i82dispd0(in,size) i8dispa(in,size[0],size[1]) + +#define u162dispd0(in,size) u16dispa(in,size[0],size[1]) + +#define i162dispd0(in,size) i16dispa(in,size[0],size[1]) + #define d3dispd0(in,size) ddisph(in,size[0],size[1],size[2]) #define g2dispd0(in, size) printf("%s\n",in) diff --git a/src/c/string/interfaces/int_string.h b/src/c/string/interfaces/int_string.h new file mode 100644 index 0000000..e90f1f9 --- /dev/null +++ b/src/c/string/interfaces/int_string.h @@ -0,0 +1,52 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Bruno JOFRET + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +/* THIS IS AN AUTOMATICALLY GENERATED FILE : DO NOT EDIT BY HAND. */ + +#ifndef __INT_STRING_H__ +#define __INT_STRING_H__ + +#include <stdio.h> + +#define s0string(in,out) sstrings(in,out) + +#define d0string(in,out) dstrings(in,out) + +#define c0string(in,out) cstrings(in,out) + +#define z0string(in,out) zstrings(in,out) + +#define u80string(in,out) u8strings(in,out) + +#define i80string(in,out) i8strings(in,out) + +#define u160string(in,out) u16strings(in,out) + +#define i160string(in,out) i16strings(in,out) + +#define s2string(in,size,out) sstringa(in,size[0]*size[1],out) + +#define d2string(in,size,out) dstringa(in,size[0]*size[1],out) + +#define c2string(in,size,out) cstringa(in,size[0]*size[1],out) + +#define z2string(in,size,out) zstringa(in,size[0]*size[1],out) + +#define u82string(in,size,out) u8stringa(in,size[0]*size[1],out) + +#define i82string(in,size,out) i8stringa(in,size[0]*size[1],out) + +#define u162string(in,size,out) u16stringa(in,size[0]*size[1],out) + +#define i162string(in,size,out) i16stringa(in,size[0]*size[1],out) + +#endif /* __INT_STRING_H__ */ diff --git a/src/c/string/string/i16stringa.c b/src/c/string/string/i16stringa.c new file mode 100644 index 0000000..28855df --- /dev/null +++ b/src/c/string/string/i16stringa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "str.h" +#include "types.h" + +void i16stringa (int16* in, int size, char** out){ + + int i = 0; + for (i = 0; i < size; ++i) + { + i16strings (in[i], out[i]); + } +} diff --git a/src/c/string/string/i16strings.c b/src/c/string/string/i16strings.c new file mode 100644 index 0000000..2f21430 --- /dev/null +++ b/src/c/string/string/i16strings.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <stdio.h> +#include "str.h" +#include "types.h" + +void i16strings (int16 in, char* out) { + + sprintf (out, "%d" ,in ); +} diff --git a/src/c/string/string/i8stringa.c b/src/c/string/string/i8stringa.c new file mode 100644 index 0000000..cf436f0 --- /dev/null +++ b/src/c/string/string/i8stringa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "str.h" +#include "types.h" + +void i8stringa (int8* in, int size, char** out){ + + int i = 0; + for (i = 0; i < size; ++i) + { + i8strings (in[i], out[i]); + } +} diff --git a/src/c/string/string/i8strings.c b/src/c/string/string/i8strings.c new file mode 100644 index 0000000..926c0f4 --- /dev/null +++ b/src/c/string/string/i8strings.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <stdio.h> +#include "str.h" +#include "types.h" + +void i8strings (int8 in, char* out) { + + sprintf (out, "%d" ,in ); +} diff --git a/src/c/string/string/u16stringa.c b/src/c/string/string/u16stringa.c new file mode 100644 index 0000000..ee5d1b3 --- /dev/null +++ b/src/c/string/string/u16stringa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "str.h" +#include "types.h" + +void u16stringa (uint16* in, int size, char** out){ + + int i = 0; + for (i = 0; i < size; ++i) + { + u16strings (in[i], out[i]); + } +} diff --git a/src/c/string/string/u16strings.c b/src/c/string/string/u16strings.c new file mode 100644 index 0000000..d2854c4 --- /dev/null +++ b/src/c/string/string/u16strings.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <stdio.h> +#include "str.h" +#include "types.h" + +void u16strings (uint16 in, char* out) { + + sprintf (out, "%d" ,in ); +} diff --git a/src/c/string/string/u8stringa.c b/src/c/string/string/u8stringa.c new file mode 100644 index 0000000..4546823 --- /dev/null +++ b/src/c/string/string/u8stringa.c @@ -0,0 +1,23 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include "str.h" +#include "types.h" + +void u8stringa (uint8* in, int size, char** out){ + + int i = 0; + for (i = 0; i < size; ++i) + { + u8strings (in[i], out[i]); + } +} diff --git a/src/c/string/string/u8strings.c b/src/c/string/string/u8strings.c new file mode 100644 index 0000000..38bf670 --- /dev/null +++ b/src/c/string/string/u8strings.c @@ -0,0 +1,20 @@ +/* + * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab + * Copyright (C) 2008-2008 - INRIA - Allan SIMON + * + * This file must be used under the terms of the CeCILL. + * This source file is licensed as described in the file COPYING, which + * you should have received as part of this distribution. The terms + * are also available at + * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt + * + */ + +#include <stdio.h> +#include "str.h" +#include "types.h" + +void u8strings (uint8 in, char* out) { + + sprintf (out, "%d" ,in ); +} |