From db464f35f5a10b58d9ed1085e0b462689adee583 Mon Sep 17 00:00:00 2001 From: Siddhesh Wani Date: Mon, 25 May 2015 14:46:31 +0530 Subject: Original Version --- src/c/operations/includes/addition.h | 115 ++++++++++++++++ src/c/operations/includes/division.h | 181 ++++++++++++++++++++++++++ src/c/operations/includes/dynlib_operations.h | 26 ++++ src/c/operations/includes/multiplication.h | 147 +++++++++++++++++++++ src/c/operations/includes/subtraction.h | 114 ++++++++++++++++ 5 files changed, 583 insertions(+) create mode 100644 src/c/operations/includes/addition.h create mode 100644 src/c/operations/includes/division.h create mode 100644 src/c/operations/includes/dynlib_operations.h create mode 100644 src/c/operations/includes/multiplication.h create mode 100644 src/c/operations/includes/subtraction.h (limited to 'src/c/operations/includes') diff --git a/src/c/operations/includes/addition.h b/src/c/operations/includes/addition.h new file mode 100644 index 00000000..d6f03381 --- /dev/null +++ b/src/c/operations/includes/addition.h @@ -0,0 +1,115 @@ +/* + * 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 + * + */ + +#ifndef __ADDITION_H__ +#define __ADDITION_H__ + +#include "dynlib_operations.h" +#include "floatComplex.h" +#include "doubleComplex.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** +** WARNING WE ASSUME MATRIXES TO BE CONSCISTENT +** size1 = size2; +** +*/ + +/* +** \brief Compute an addition with floats. +** \param in1 : input float. +** \param in2 : input float. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS float sadds(float in1, float in2); + +/* +** \brief Compute an addition element ways for floats. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void sadda(float *in1, int size1, + float *in2, int size2, + float *out); + +/* +** \brief Compute an addition with double. +** \param in1 : input double. +** \param in2 : input double. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS double dadds(double in1, double in2); + +/* +** \brief Compute an addition element ways for double. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void dadda(double *in1, int size1, + double *in2, int size2, + double * out); + +/* +** \brief Compute an addition with floats Complex. +** \param in1 : input float complex. +** \param in2 : input float complex. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS floatComplex cadds(floatComplex in1, floatComplex in2); + +/* +** \brief Compute an addition element ways for complex single precision. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void cadda(floatComplex *in1, int size1, + floatComplex *in2, int size2, + floatComplex *out); + +/* +** \brief Compute an addition with double complex. +** \param in1 : input double complex. +** \param in2 : input double conplex. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS doubleComplex zadds(doubleComplex in1, doubleComplex in2); + +/* +** \brief Compute an addition element ways for complex double precision. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void zadda(doubleComplex *in1, int size1, + doubleComplex *in2, int size2, + doubleComplex *out); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* !__ADDITION_H__ */ diff --git a/src/c/operations/includes/division.h b/src/c/operations/includes/division.h new file mode 100644 index 00000000..df4c5d2a --- /dev/null +++ b/src/c/operations/includes/division.h @@ -0,0 +1,181 @@ +/* + * 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 + * + */ + +#ifndef __DIVISION_H__ +#define __DIVISION_H__ + +#include "dynlib_operations.h" +#include "floatComplex.h" +#include "doubleComplex.h" + +#ifdef __cplusplus +extern "C" { +#endif + +/* +** +** WARNING WE ASSUME MATRIXES TO BE CONSCISTENT +** size1 = size2; +** +*/ + + +/* +** RIGHT DIVISION +*/ + +/* +** \brief Compute a right division for floats. +** \param in1 : input float. +** \param in2 : input float. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS float srdivs (float in1, float in2); + +/* +** \brief Compute a right division element ways for floats. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void srdiva (float* in1, float* in2, int size, float* out ); + +/* +** \brief Compute a right division for double. +** \param in1 : input double. +** \param in2 : input double. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS double drdivs (double in1, double in2); + +/* +** \brief Compute a right division element ways for double. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void drdiva (double* in1, double* in2, int size, double* out ); + +/* +** \brief Compute a right division for floats complex. +** \param in1 : input float complex. +** \param in2 : input float complex. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS floatComplex crdivs (floatComplex in1, floatComplex in2); + +/* +** \brief Compute a right division element ways for float complex. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void crdiva(floatComplex* in1, floatComplex* in2, int size, floatComplex* out ); + +/* +** \brief Compute a right division for double complex. +** \param in1 : input double complex. +** \param in2 : input double complex. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS doubleComplex zrdivs (doubleComplex in1, doubleComplex in2); + +/* +** \brief Compute a right division element ways for double complex. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void zrdiva(doubleComplex* in1, doubleComplex* in2, int size, doubleComplex* out ); + +/* +** LEFT DIVISION +*/ + +/* +** \brief Compute a left division for floats. +** \param in1 : input float. +** \param in2 : input float. +** \return in1 \ in2 = in1 .\ in2. +*/ +EXTERN_OPERATIONS float sldivs (float in1, float in2); + +/* +** \brief Compute a left division element ways for floats. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void sldiva (float* in1, float* in2, int size, float* out ); + +/* +** \brief Compute a left division for double. +** \param in1 : input double. +** \param in2 : input double. +** \return in1 \ in2 = in1 .\ in2. +*/ +EXTERN_OPERATIONS double dldivs (double in1, double in2); + +/* +** \brief Compute a left division element ways for double. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void dldiva (double* in1, double* in2, int size, double* out ); + +/* +** \brief Compute a left division for floats complex. +** \param in1 : input float complex. +** \param in2 : input float complex. +** \return in1 \ in2 = in1 .\ in2. +*/ +EXTERN_OPERATIONS floatComplex cldivs (floatComplex in1, floatComplex in2); + +/* +** \brief Compute a left division element ways for float complex. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void cldiva(floatComplex* in1, floatComplex* in2, int size, floatComplex* out ); + +/* +** \brief Compute a left division for double complex. +** \param in1 : input double complex. +** \param in2 : input double complex. +** \return in1 \ in2 = in1 .\ in2. +*/ +EXTERN_OPERATIONS doubleComplex zldivs (doubleComplex in1, doubleComplex in2); + +/* +** \brief Compute a left division element ways for double complex. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void zldiva(doubleComplex* in1, doubleComplex* in2, int size, doubleComplex* out ); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + + +#endif /* !__DIVISION_H__ */ diff --git a/src/c/operations/includes/dynlib_operations.h b/src/c/operations/includes/dynlib_operations.h new file mode 100644 index 00000000..e91f6322 --- /dev/null +++ b/src/c/operations/includes/dynlib_operations.h @@ -0,0 +1,26 @@ +/* +* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab +* Copyright (C) 2009 - DIGITEO - Allan CORNET +* +* 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 +* +*/ + +#ifndef __DYNLIB_OPERATIONS_H__ +#define __DYNLIB_OPERATIONS_H__ + +#if defined(_MSC_VER) && defined(_USRDLL) + #if OPERATIONS_EXPORTS + #define EXTERN_OPERATIONS __declspec (dllexport) + #else + #define EXTERN_OPERATIONS __declspec (dllimport) + #endif +#else + #define EXTERN_OPERATIONS +#endif + +#endif /* __DYNLIB_OPERATIONS_H__ */ diff --git a/src/c/operations/includes/multiplication.h b/src/c/operations/includes/multiplication.h new file mode 100644 index 00000000..9931a9a9 --- /dev/null +++ b/src/c/operations/includes/multiplication.h @@ -0,0 +1,147 @@ +/* + * 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 + * + */ + +#ifndef __MULTIPLICATION_H__ +#define __MULTIPLICATION_H__ + +#include "dynlib_operations.h" +#include "floatComplex.h" +#include "doubleComplex.h" + +#ifdef __cplusplus +extern "C" { +#endif +/* +** +** WARNING WE ASSUME MATRIXES TO BE CONSCISTENT +** size1 = size2; +** +*/ + +/* +** \brief Compute a multiplication with floats. +** \param in1 : input float. +** \param in2 : input float. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS float smuls(float in1, float in2); + +/* +** \brief Compute a multiplication element ways for floats. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void smula(float *in1, float *in2, int size2, float *out); + +/* +** \brief Compute a multiplication for floats. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS float smulv(float *in1, float *in2, int size2); + +/* +** \brief Compute a multiplication with double. +** \param in1 : input double. +** \param in2 : input double. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS double dmuls(double in1, double in2); + +/* +** \brief Compute a multiplication element ways for double. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void dmula(double *in1, double *in2, int size,double * out); + +/* +** \brief Compute a multiplication for floats. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS double dmulv(double *in1, double *in2, int size2); + +/* +** \brief Compute a multiplication with floats Complex. +** \param in1 : input float complex. +** \param in2 : input float complex. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS floatComplex cmuls(floatComplex in1, floatComplex in2); + +/* +** \brief Compute a multiplication element ways for complex single precision. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void cmula(floatComplex *in1, floatComplex *in2, int size, floatComplex *out); + +/* +** \brief Compute a multiplication for floats. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS floatComplex cmulv(floatComplex *in1, floatComplex *in2, int size2); + +EXTERN_OPERATIONS floatComplex cmulcsv(floatComplex *in1, float *in2, int size2); + +EXTERN_OPERATIONS floatComplex cmulscv(float *in1, floatComplex *in2, int size2); + + +/* +** \brief Compute a multiplication with double complex. +** \param in1 : input double complex. +** \param in2 : input double conplex. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS doubleComplex zmuls(doubleComplex in1, doubleComplex in2); + +/* +** \brief Compute a multiplication element ways for complex double precision. +** \param in1 : input array. +** \param in2 : input array. +** \param size: size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void zmula(doubleComplex *in1, doubleComplex *in2, int size, doubleComplex *out); + +/* +** \brief Compute a multiplication for double. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS doubleComplex zmulv(doubleComplex *in1, doubleComplex *in2, int size2); + +EXTERN_OPERATIONS doubleComplex zmulzdv(doubleComplex *in1, double *in2, int size2); + +EXTERN_OPERATIONS doubleComplex zmuldzv(double *in1, doubleComplex *in2, int size2); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* !__MULTIPLICATION_H__ */ diff --git a/src/c/operations/includes/subtraction.h b/src/c/operations/includes/subtraction.h new file mode 100644 index 00000000..8571a5de --- /dev/null +++ b/src/c/operations/includes/subtraction.h @@ -0,0 +1,114 @@ +/* + * 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 + * + */ + +#ifndef __SUBTRACTION_H__ +#define __SUBTRACTION_H__ + +#include "dynlib_operations.h" +#include "floatComplex.h" +#include "doubleComplex.h" + +#ifdef __cplusplus +extern "C" { +#endif +/* +** +** WARNING WE ASSUME MATRIXES TO BE CONSCISTENT +** size1 = size2; +** +*/ + +/* +** \brief Compute a subtraction with floats. +** \param in1 : input float. +** \param in2 : input float. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS float sdiffs(float in1, float in2); + +/* +** \brief Compute a subtraction element ways for floats. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void sdiffa(float *in1, int size1, + float *in2, int size2, + float *out); + +/* +** \brief Compute a subtraction with double. +** \param in1 : input double. +** \param in2 : input double. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS double ddiffs(double in1, double in2); + +/* +** \brief Compute a subtraction element ways for double. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void ddiffa(double *in1, int size1, + double *in2, int size2, + double * out); + +/* +** \brief Compute a subtraction with floats Complex. +** \param in1 : input float complex. +** \param in2 : input float complex. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS floatComplex cdiffs(floatComplex in1, floatComplex in2); + +/* +** \brief Compute a subtraction element ways for complex single precision. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void cdiffa(floatComplex *in1, int size1, + floatComplex *in2, int size2, + floatComplex *out); + +/* +** \brief Compute a subtraction with double complex. +** \param in1 : input double complex. +** \param in2 : input double conplex. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS doubleComplex zdiffs(doubleComplex in1, doubleComplex in2); + +/* +** \brief Compute a subtraction element ways for complex double precision. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void zdiffa(doubleComplex *in1, int size1, + doubleComplex *in2, int size2, + doubleComplex *out); + +#ifdef __cplusplus +} /* extern "C" */ +#endif + +#endif /* !__SUBTRACTION_H__ */ -- cgit From 14496b5b41e6d2e7323d9c5e860e6b56e385a062 Mon Sep 17 00:00:00 2001 From: Siddhesh Wani Date: Tue, 4 Aug 2015 14:36:45 +0530 Subject: Tested Addition and Subtraction for new data types --- src/c/operations/includes/addition.h | 81 ++++++++++++++++++++++++++++++++ src/c/operations/includes/subtraction.h | 83 +++++++++++++++++++++++++++++++++ 2 files changed, 164 insertions(+) (limited to 'src/c/operations/includes') diff --git a/src/c/operations/includes/addition.h b/src/c/operations/includes/addition.h index d6f03381..fbf0177b 100644 --- a/src/c/operations/includes/addition.h +++ b/src/c/operations/includes/addition.h @@ -16,6 +16,7 @@ #include "dynlib_operations.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -108,6 +109,86 @@ EXTERN_OPERATIONS void zadda(doubleComplex *in1, int size1, doubleComplex *in2, int size2, doubleComplex *out); +/* +** \brief Compute an addition with uint8. +** \param in1 : input uint8. +** \param in2 : input uint8. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS uint8 u8adds(uint8 in1, uint8 in2); + +/* +** \brief Compute an addition element wise for uint8. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void u8adda(uint8 *in1, int size1, + uint8 *in2, int size2, + uint8 *out); + +/* +** \brief Compute an addition with int8. +** \param in1 : input int8. +** \param in2 : input int8. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS int8 i8adds(int8 in1, int8 in2); + +/* +** \brief Compute an addition element wise for int8. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void i8adda(int8 *in1, int size1, + int8 *in2, int size2, + int8 *out); + +/* +** \brief Compute an addition with uint16. +** \param in1 : input uint16. +** \param in2 : input uint16. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS uint16 u16adds(uint16 in1, uint16 in2); + +/* +** \brief Compute an addition element wise for uint16. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void u16adda(uint16 *in1, int size1, + uint16 *in2, int size2, + uint16 *out); + +/* +** \brief Compute an addition with int16. +** \param in1 : input int16. +** \param in2 : input int16. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS int16 i16adds(int16 in1, int16 in2); + +/* +** \brief Compute an addition element wise for int16. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the addition in1 + in2. +*/ +EXTERN_OPERATIONS void i16adda(int16 *in1, int size1, + int16 *in2, int size2, + int16 *out); + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/operations/includes/subtraction.h b/src/c/operations/includes/subtraction.h index 8571a5de..798df2bf 100644 --- a/src/c/operations/includes/subtraction.h +++ b/src/c/operations/includes/subtraction.h @@ -16,6 +16,7 @@ #include "dynlib_operations.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -107,6 +108,88 @@ EXTERN_OPERATIONS void zdiffa(doubleComplex *in1, int size1, doubleComplex *in2, int size2, doubleComplex *out); + +/* +** \brief Compute a subtraction with uint8. +** \param in1 : input uint8. +** \param in2 : input uint8. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS uint8 u8diffs(uint8 in1, uint8 in2); + +/* +** \brief Compute a subtraction element wise for uint8. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void u8diffa(uint8 *in1, int size1, + uint8 *in2, int size2, + uint8 *out); + +/* +** \brief Compute a subtraction with int8. +** \param in1 : input int8. +** \param in2 : input int8. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS int8 i8diffs(int8 in1, int8 in2); + +/* +** \brief Compute a subtraction element wise for int8. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void i8diffa(int8 *in1, int size1, + int8 *in2, int size2, + int8 *out); + + +/* +** \brief Compute a subtraction with uint16. +** \param in1 : input uint16. +** \param in2 : input uint16. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS uint16 u16diffs(uint16 in1, uint16 in2); + +/* +** \brief Compute a subtraction element wise for uint16. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void u16diffa(uint16 *in1, int size1, + uint16 *in2, int size2, + uint16 *out); + +/* +** \brief Compute a subtraction with int16. +** \param in1 : input int16. +** \param in2 : input int16. +** \return : in1 + in2 +*/ +EXTERN_OPERATIONS int16 i16diffs(int16 in1, int16 in2); + +/* +** \brief Compute a subtraction element wise for int16. +** \param in1 : input array. +** \param size1 : size of in1 array. +** \param in2 : input arry. +** \param size2 : size of in2 array. +** \param out : array that contains the subtraction in1 + in2. +*/ +EXTERN_OPERATIONS void i16diffa(int16 *in1, int size1, + int16 *in2, int size2, + int16 *out); + #ifdef __cplusplus } /* extern "C" */ #endif -- cgit From aba32804a6cbd6fb16e13e86364e643022a2941a Mon Sep 17 00:00:00 2001 From: Siddhesh Wani Date: Thu, 6 Aug 2015 01:10:39 +0530 Subject: Multiplication tested for new data types --- src/c/operations/includes/division.h | 67 ++++++++++++++++++++++++++++ src/c/operations/includes/multiplication.h | 70 ++++++++++++++++++++++++++++++ 2 files changed, 137 insertions(+) (limited to 'src/c/operations/includes') diff --git a/src/c/operations/includes/division.h b/src/c/operations/includes/division.h index df4c5d2a..eedf4a3f 100644 --- a/src/c/operations/includes/division.h +++ b/src/c/operations/includes/division.h @@ -16,6 +16,7 @@ #include "dynlib_operations.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -101,6 +102,38 @@ EXTERN_OPERATIONS doubleComplex zrdivs (doubleComplex in1, doubleComplex in2); */ EXTERN_OPERATIONS void zrdiva(doubleComplex* in1, doubleComplex* in2, int size, doubleComplex* out ); +/* +** \brief Compute a right division for uint8. +** \param in1 : input uint8. +** \param in2 : input uint8. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS uint8 u8rdivs (uint8 in1, uint8 in2); + +/* +** \brief Compute a right division for int8. +** \param in1 : input int8. +** \param in2 : input int8. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS int8 i8rdivs (int8 in1, int8 in2); + +/* +** \brief Compute a right division for uint16. +** \param in1 : input uint16. +** \param in2 : input uint16. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS uint16 u16rdivs (uint16 in1, uint16 in2); + +/* +** \brief Compute a right division for int16. +** \param in1 : input int16. +** \param in2 : input int16. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS int16 i16rdivs (int16 in1, int16 in2); + /* ** LEFT DIVISION */ @@ -173,6 +206,40 @@ EXTERN_OPERATIONS doubleComplex zldivs (doubleComplex in1, doubleComplex in2); */ EXTERN_OPERATIONS void zldiva(doubleComplex* in1, doubleComplex* in2, int size, doubleComplex* out ); +/* +** \brief Compute a right division for uint8. +** \param in1 : input uint8. +** \param in2 : input uint8. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS uint8 u8ldivs (uint8 in1, uint8 in2); + +/* +** \brief Compute a right division for int8. +** \param in1 : input int8. +** \param in2 : input int8. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS int8 i8ldivs (int8 in1, int8 in2); + +/* +** \brief Compute a right division for uint16. +** \param in1 : input uint16. +** \param in2 : input uint16. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS uint16 u16ldivs (uint16 in1, uint16 in2); + +/* +** \brief Compute a right division for int16. +** \param in1 : input int16. +** \param in2 : input int16. +** \return in1 / in2 = in1 ./ in2. +*/ +EXTERN_OPERATIONS int16 i16ldivs (int16 in1, int16 in2); + + + #ifdef __cplusplus } /* extern "C" */ #endif diff --git a/src/c/operations/includes/multiplication.h b/src/c/operations/includes/multiplication.h index 9931a9a9..8b08d6df 100644 --- a/src/c/operations/includes/multiplication.h +++ b/src/c/operations/includes/multiplication.h @@ -16,6 +16,7 @@ #include "dynlib_operations.h" #include "floatComplex.h" #include "doubleComplex.h" +#include "types.h" #ifdef __cplusplus extern "C" { @@ -140,6 +141,75 @@ EXTERN_OPERATIONS doubleComplex zmulzdv(doubleComplex *in1, double *in2, int siz EXTERN_OPERATIONS doubleComplex zmuldzv(double *in1, doubleComplex *in2, int size2); +/* +** \brief Compute a multiplication with uint8. +** \param in1 : input uint8. +** \param in2 : input uint8. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS uint8 u8muls(uint8 in1, uint8 in2); + +/* +** \brief Compute a multiplication for uint8 arrays. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS uint8 u8mulv(uint8 *in1, uint8 *in2, int size2); + +/* +** \brief Compute a multiplication with int8. +** \param in1 : input int8. +** \param in2 : input int8. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS int8 i8muls(int8 in1, int8 in2); + +/* +** \brief Compute a multiplication for int8 arrays. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS int8 i8mulv(int8 *in1, int8 *in2, int size2); + +/* +** \brief Compute a multiplication with uint16. +** \param in1 : input uint16. +** \param in2 : input uint16. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS uint16 u16muls(uint16 in1, uint16 in2); + +/* +** \brief Compute a multiplication for uint16 arrays. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS uint16 u16mulv(uint16 *in1, uint16 *in2, int size2); + +/* +** \brief Compute a multiplication with int16. +** \param in1 : input int16. +** \param in2 : input int16. +** \return : in1 * in 2 = in1 .* in2. +*/ +EXTERN_OPERATIONS int16 i16muls(int16 in1, int16 in2); + +/* +** \brief Compute a multiplication for int16 arrays. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \return : scalar that contains the multiplication of the two vectors = in1 .* in2. +*/ +EXTERN_OPERATIONS int16 i16mulv(int16 *in1, int16 *in2, int size2); + + #ifdef __cplusplus } /* extern "C" */ #endif -- cgit From 1247157de6d55146f6c544bd47c21a5326a64725 Mon Sep 17 00:00:00 2001 From: imushir Date: Fri, 27 Nov 2015 15:47:47 +0530 Subject: #define for u8 u16 i8 i16 added --- src/c/operations/includes/division.h | 80 ++++++++++++++++++++++++++++++ src/c/operations/includes/multiplication.h | 36 ++++++++++++++ 2 files changed, 116 insertions(+) (limited to 'src/c/operations/includes') diff --git a/src/c/operations/includes/division.h b/src/c/operations/includes/division.h index eedf4a3f..ac2d1482 100644 --- a/src/c/operations/includes/division.h +++ b/src/c/operations/includes/division.h @@ -102,14 +102,46 @@ EXTERN_OPERATIONS doubleComplex zrdivs (doubleComplex in1, doubleComplex in2); */ EXTERN_OPERATIONS void zrdiva(doubleComplex* in1, doubleComplex* in2, int size, doubleComplex* out ); + +/* +** \brief Compute a right division element ways for uint8. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void u8rdiva (uint8* in1, uint8* in2, int size, uint8* out ); + + + /* ** \brief Compute a right division for uint8. ** \param in1 : input uint8. ** \param in2 : input uint8. ** \return in1 / in2 = in1 ./ in2. */ + EXTERN_OPERATIONS uint8 u8rdivs (uint8 in1, uint8 in2); +/* +** \brief Compute a right division element ways for uint16. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void u16rdiva (uint16* in1, uint16* in2, int size, uint16* out ); + + +/* +** \brief Compute a right division element ways for int8. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void i8rdiva (int8* in1, int8* in2, int size, int8* out ); + /* ** \brief Compute a right division for int8. ** \param in1 : input int8. @@ -134,6 +166,16 @@ EXTERN_OPERATIONS uint16 u16rdivs (uint16 in1, uint16 in2); */ EXTERN_OPERATIONS int16 i16rdivs (int16 in1, int16 in2); +/* +** \brief Compute a right division element ways for int16. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 ./ in2. +*/ +EXTERN_OPERATIONS void i16rdiva (int16* in1, int16* in2, int size, int16* out ); + + /* ** LEFT DIVISION */ @@ -206,6 +248,15 @@ EXTERN_OPERATIONS doubleComplex zldivs (doubleComplex in1, doubleComplex in2); */ EXTERN_OPERATIONS void zldiva(doubleComplex* in1, doubleComplex* in2, int size, doubleComplex* out ); +/* +** \brief Compute a left division element ways for uint8. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void u8ldiva (uint8* in1, uint8* in2, int size, uint8* out ); + /* ** \brief Compute a right division for uint8. ** \param in1 : input uint8. @@ -214,6 +265,15 @@ EXTERN_OPERATIONS void zldiva(doubleComplex* in1, doubleComplex* in2, int size, */ EXTERN_OPERATIONS uint8 u8ldivs (uint8 in1, uint8 in2); +/* +** \brief Compute a left division element ways for int8. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void i8ldiva (int8* in1, int8* in2, int size, int8* out ); + /* ** \brief Compute a right division for int8. ** \param in1 : input int8. @@ -222,6 +282,16 @@ EXTERN_OPERATIONS uint8 u8ldivs (uint8 in1, uint8 in2); */ EXTERN_OPERATIONS int8 i8ldivs (int8 in1, int8 in2); +/* +** \brief Compute a left division element ways for uint16. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void u16ldiva (uint16* in1, uint16* in2, int size, uint16* out ); + + /* ** \brief Compute a right division for uint16. ** \param in1 : input uint16. @@ -230,6 +300,16 @@ EXTERN_OPERATIONS int8 i8ldivs (int8 in1, int8 in2); */ EXTERN_OPERATIONS uint16 u16ldivs (uint16 in1, uint16 in2); +/* +** \brief Compute a left division element ways for int16. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array = rows*columns. +** \param out : array that contains the division in1 .\ in2. +*/ +EXTERN_OPERATIONS void i16ldiva (int16* in1, int16* in2, int size, int16* out ); + + /* ** \brief Compute a right division for int16. ** \param in1 : input int16. diff --git a/src/c/operations/includes/multiplication.h b/src/c/operations/includes/multiplication.h index 8b08d6df..32ea932b 100644 --- a/src/c/operations/includes/multiplication.h +++ b/src/c/operations/includes/multiplication.h @@ -141,6 +141,15 @@ EXTERN_OPERATIONS doubleComplex zmulzdv(doubleComplex *in1, double *in2, int siz EXTERN_OPERATIONS doubleComplex zmuldzv(double *in1, doubleComplex *in2, int size2); +/* +** \brief Compute a multiplication element ways for uint8. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void u8mula(uint8 *in1, uint8 *in2, int size,uint8 * out); + /* ** \brief Compute a multiplication with uint8. ** \param in1 : input uint8. @@ -158,6 +167,15 @@ EXTERN_OPERATIONS uint8 u8muls(uint8 in1, uint8 in2); */ EXTERN_OPERATIONS uint8 u8mulv(uint8 *in1, uint8 *in2, int size2); +/* +** \brief Compute a multiplication element ways for int8. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void i8mula(int8 *in1, int8 *in2, int size,int8 * out); + /* ** \brief Compute a multiplication with int8. ** \param in1 : input int8. @@ -175,6 +193,15 @@ EXTERN_OPERATIONS int8 i8muls(int8 in1, int8 in2); */ EXTERN_OPERATIONS int8 i8mulv(int8 *in1, int8 *in2, int size2); +/* +** \brief Compute a multiplication element ways for uint16. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void u16mula(uint16 *in1, uint16 *in2, int size,uint16 * out); + /* ** \brief Compute a multiplication with uint16. ** \param in1 : input uint16. @@ -192,6 +219,15 @@ EXTERN_OPERATIONS uint16 u16muls(uint16 in1, uint16 in2); */ EXTERN_OPERATIONS uint16 u16mulv(uint16 *in1, uint16 *in2, int size2); +/* +** \brief Compute a multiplication element ways for int16. +** \param in1 : input array. +** \param in2 : input array. +** \param size : size of in2 array. +** \param out : array that contains the multiplication = in1 .* in2. +*/ +EXTERN_OPERATIONS void i16mula(int16 *in1, int16 *in2, int size,int16 * out); + /* ** \brief Compute a multiplication with int16. ** \param in1 : input int16. -- cgit