Merge branch 'master' of https://github.com/siddhu8990/Scilab2C

26 files changed, 1133 insertions, 1 deletions

diff --git a/2.3-1/src/c/matrixOperations/cat/i16cata.c b/2.3-1/src/c/matrixOperations/cat/i16cata.c
new file mode 100644
index 00000000..9acd10ec
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/i16cata.c
@@ -0,0 +1,53 @@
+/* Scilab2C FOSSEE IIT BOMBAY*/
+#include "cat.h"
+/* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(1,A1,A2);
+output => y = [1 2 3; 4 5 6;7 8 9;10 11 12]
+*/
+
+void i16rowcata(int16 *in1,int lines1,int columns1,int16 *in2,int lines2,int columns2,int16* out)
+{
+ int i = 0;
+ int j = 0;
+ for(i = 0;i < columns1 && i < columns2; ++i)
+  {
+    for(j = 0;j < lines1; ++j)
+    {
+       out[i*(lines1 + lines2) + j] = in1[i*lines1 + j];
+    }
+    for(j = 0;j < lines2; ++j)
+      {
+        out[i*(lines1 + lines2) + lines1 + j] = in2[i*lines2 + j];
+      }
+
+  }
+}
+
+  /* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(2,A1,A2);
+output => y = [1 2 3 7 8 9; 4 5 6 10 11 12]
+*/
+
+void i16columncata(int16 *in1,int lines1,int columns1,int16 *in2,int lines2,int columns2,int16* out)
+   {
+     int i = 0;
+     for(i = 0; i < lines1 * columns1;++i)
+      {
+          out[i] = in1[i];
+ 
+      }
+      for(i = 0;i < lines2 * columns2;++i)
+      {
+        
+        out[i + lines1 * columns2] = in2[i];
+
+      }
+  
+   }
+
+
+
diff --git a/2.3-1/src/c/matrixOperations/cat/i16cats.c b/2.3-1/src/c/matrixOperations/cat/i16cats.c
new file mode 100644
index 00000000..8d8af28f
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/i16cats.c
@@ -0,0 +1,16 @@
+/* Scilab2C FOSSEE IIT BOMBAY*/
+#include "cat.h"
+
+void i16rowcats(int16 in1,int16 in2,int16 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
+
+void i16columncats(int16 in1,int16 in2,int16 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
diff --git a/2.3-1/src/c/matrixOperations/cat/i8cata.c b/2.3-1/src/c/matrixOperations/cat/i8cata.c
new file mode 100644
index 00000000..a2caad95
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/i8cata.c
@@ -0,0 +1,50 @@
+/* Scilab2C FOSSEE IIT BOMBAY*/
+#include "cat.h"
+/* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(1,A1,A2);
+output => y = [1 2 3; 4 5 6;7 8 9;10 11 12]
+*/
+
+void i8rowcata(int8 *in1,int lines1,int columns1,int8 *in2,int lines2,int columns2,int8* out)
+{
+ int i = 0;
+ int j = 0;
+ for(i = 0;i < columns1 && i < columns2; ++i)
+  {
+    for(j = 0;j < lines1; ++j)
+    {
+       out[i*(lines1 + lines2) + j] = in1[i*lines1 + j];
+    }
+    for(j = 0;j < lines2; ++j)
+      {
+        out[i*(lines1 + lines2) + lines1 + j] = in2[i*lines2 + j];
+      }
+
+  }
+}
+  /* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(2,A1,A2);
+output => y = [1 2 3 7 8 9; 4 5 6 10 11 12]
+*/
+
+void i8columncata(int8 *in1,int lines1,int columns1,int8 *in2,int lines2,int columns2,int8* out)
+   {
+     int i = 0;
+     for(i = 0; i < lines1 * columns1;++i)
+      {
+          out[i] = in1[i];
+ 
+      }
+      for(i = 0;i < lines2 * columns2;++i)
+      {
+        
+        out[i + lines1 * columns2] = in2[i];
+
+      }
+  
+   }
+
diff --git a/2.3-1/src/c/matrixOperations/cat/i8cats.c b/2.3-1/src/c/matrixOperations/cat/i8cats.c
new file mode 100644
index 00000000..575f8a8f
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/i8cats.c
@@ -0,0 +1,16 @@
+/* Scilab 2C FOSSEE IIT BOMBAY */
+#include "cat.h"
+
+void i8rowcats(int8 in1,int8 in2,int8 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
+
+void i8columncats(int8 in1,uint8 in2,int8 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
diff --git a/2.3-1/src/c/matrixOperations/cat/u16cata.c b/2.3-1/src/c/matrixOperations/cat/u16cata.c
new file mode 100644
index 00000000..2b756e59
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/u16cata.c
@@ -0,0 +1,53 @@
+/* Scilab2C FOSSEE IIT BOMBAY*/
+#include "cat.h"
+/* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(1,A1,A2);
+output => y = [1 2 3; 4 5 6;7 8 9;10 11 12]
+*/
+
+void u16rowcata(uint16 *in1,int lines1,int columns1,uint16 *in2,int lines2,int columns2,uint16* out)
+{
+ int i = 0;
+ int j = 0;
+ for(i = 0;i < columns1 && i < columns2; ++i)
+  {
+    for(j = 0;j < lines1; ++j)
+    {
+       out[i*(lines1 + lines2) + j] = in1[i*lines1 + j];
+    }
+    for(j = 0;j < lines2; ++j)
+      {
+        out[i*(lines1 + lines2) + lines1 + j] = in2[i*lines2 + j];
+      }
+
+  }
+}
+
+  /* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(2,A1,A2);
+output => y = [1 2 3 7 8 9; 4 5 6 10 11 12]
+*/
+
+void u16columncata(uint16 *in1,int lines1,int columns1,uint16 *in2,int lines2,int columns2,uint16* out)
+   {
+     int i = 0;
+     for(i = 0; i < lines1 * columns1;++i)
+      {
+          out[i] = in1[i];
+ 
+      }
+      for(i = 0;i < lines2 * columns2;++i)
+      {
+        
+        out[i + lines1 * columns2] = in2[i];
+
+      }
+  
+   }
+
+
+
diff --git a/2.3-1/src/c/matrixOperations/cat/u16cats.c b/2.3-1/src/c/matrixOperations/cat/u16cats.c
new file mode 100644
index 00000000..e4170490
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/u16cats.c
@@ -0,0 +1,16 @@
+/* Scilab2C FOSSEE IIT BOMBAY*/
+#include "cat.h"
+
+void u16rowcats(uint16 in1,uint16 in2,uint16 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
+
+void u16columncats(uint16 in1,uint16 in2,uint16 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
diff --git a/2.3-1/src/c/matrixOperations/cat/u8cata.c b/2.3-1/src/c/matrixOperations/cat/u8cata.c
new file mode 100644
index 00000000..29163238
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/u8cata.c
@@ -0,0 +1,50 @@
+/* Scilab2C FOSSEE IIT BOMBAY*/
+#include "cat.h"
+/* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(1,A1,A2);
+output => y = [1 2 3; 4 5 6;7 8 9;10 11 12]
+*/
+
+void u8rowcata(uint8 *in1,int lines1,int columns1,uint8 *in2,int lines2,int columns2,uint8* out)
+{
+ int i = 0;
+ int j = 0;
+ for(i = 0;i < columns1 && i < columns2; ++i)
+  {
+    for(j = 0;j < lines1; ++j)
+    {
+       out[i*(lines1 + lines2) + j] = in1[i*lines1 + j];
+    }
+    for(j = 0;j < lines2; ++j)
+      {
+        out[i*(lines1 + lines2) + lines1 + j] = in2[i*lines2 + j];
+      }
+
+  }
+}
+  /* From scilab help cat then the concatenation is done according to the rows
+A1 = [1 2 3;4 5 6];
+A2 = [7 8 9;10 11 12];
+y = cat(2,A1,A2);
+output => y = [1 2 3 7 8 9; 4 5 6 10 11 12]
+*/
+
+void u8columncata(uint8 *in1,int lines1,int columns1,uint8 *in2,int lines2,int columns2,uint8* out)
+   {
+     int i = 0;
+     for(i = 0; i < lines1 * columns1;++i)
+      {
+          out[i] = in1[i];
+ 
+      }
+      for(i = 0;i < lines2 * columns2;++i)
+      {
+        
+        out[i + lines1 * columns2] = in2[i];
+
+      }
+  
+   }
+
diff --git a/2.3-1/src/c/matrixOperations/cat/u8cats.c b/2.3-1/src/c/matrixOperations/cat/u8cats.c
new file mode 100644
index 00000000..249a6b8c
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/cat/u8cats.c
@@ -0,0 +1,16 @@
+/* Scilab2C FOSSEE IIT BOMBAY*/
+#include "cat.h"
+
+void u8rowcats(uint8 in1,uint8 in2,uint8 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
+
+void u8columncats(uint8 in1,uint8 in2,uint8 *out)
+{
+  out[0] = in1;
+  out[1] = in2;
+
+}
diff --git a/2.3-1/src/c/matrixOperations/includes/cat.h b/2.3-1/src/c/matrixOperations/includes/cat.h
index 9f64a157..dde6b9bd 100644
--- a/2.3-1/src/c/matrixOperations/includes/cat.h
+++ b/2.3-1/src/c/matrixOperations/includes/cat.h
@@ -12,7 +12,7 @@
 
 #ifndef __CAT_H__
 #define __CAT_H__
-
+#include "types.h"
 #include "dynlib_matrixoperations.h"
 #include "floatComplex.h"
 #include "doubleComplex.h"
@@ -98,6 +98,63 @@ EXTERN_MATOPS void		ccolumncata(floatComplex *in1, int lines1, int columns1, flo
 EXTERN_MATOPS void		zrowcata(doubleComplex *in1, int lines1, int columns1, doubleComplex *in2, int lines2, int columns2, doubleComplex* out);
 EXTERN_MATOPS void		zcolumncata(doubleComplex *in1, int lines1, int columns1, doubleComplex *in2, int lines2, int columns2, doubleComplex* out);
 
+/*
+** \brief Concat uint8 arrays
+** \param in1 the uint8 array to process
+** \param lines1
+** \param columns1
+** \param in2 the uint8  array to process to concat
+** \param lines2
+** \param columns2
+** \param out the concatenation
+*/
+
+EXTERN_MATOPS void u8rowcata(uint8 *in1, int lines1, int columns1, uint8 *in2, int lines2, int columns2, uint8* out);
+EXTERN_MATOPS void u8columncata(uint8 *in1, int lines1, int columns1, uint8 *in2, int lines2, int columns2, uint8* out);
+
+/*
+** \brief Concat uint16 arrays
+** \param in1 the uint16 array to process
+** \param lines1
+** \param columns1
+** \param in2 the uint16  array to process to concat
+** \param lines2
+** \param columns2
+** \param out the concatenation
+*/
+
+EXTERN_MATOPS void u16rowcata(uint16 *in1, int lines1, int columns1, uint16 *in2, int lines2, int columns2, uint16* out);
+EXTERN_MATOPS void u16columncata(uint16 *in1, int lines1, int columns1, uint16 *in2, int lines2, int columns2, uint16* out);
+
+
+/*
+** \brief Concat int8 arrays
+** \param in1 the int8 array to process
+** \param lines1
+** \param columns1
+** \param in2 the int8  array to process to concat
+** \param lines2
+** \param columns2
+** \param out the concatenation
+*/
+
+EXTERN_MATOPS void i8rowcata(int8 *in1, int lines1, int columns1, int8 *in2, int lines2, int columns2, int8* out);
+EXTERN_MATOPS void i8columncata(int8 *in1, int lines1, int columns1, int8 *in2, int lines2, int columns2, int8* out);
+
+/*
+** \brief Concat int16 arrays
+** \param in1 the int16 array to process
+** \param lines1
+** \param columns1
+** \param in2 the int16  array to process to concat
+** \param lines2
+** \param columns2
+** \param out the concatenation
+*/
+
+EXTERN_MATOPS void i16rowcata(int16 *in1, int lines1, int columns1, int16 *in2, int lines2, int columns2, int16* out);
+EXTERN_MATOPS void i16columncata(int16 *in1, int lines1, int columns1, int16 *in2, int lines2, int columns2, int16* out);
+
 #ifdef  __cplusplus
 } /* extern "C" */
 #endif
diff --git a/2.3-1/src/c/matrixOperations/includes/matrixMagnitude.h b/2.3-1/src/c/matrixOperations/includes/matrixMagnitude.h
index 7b65c6d9..a9f4e71c 100644
--- a/2.3-1/src/c/matrixOperations/includes/matrixMagnitude.h
+++ b/2.3-1/src/c/matrixOperations/includes/matrixMagnitude.h
@@ -17,6 +17,7 @@
 #include "dynlib_matrixoperations.h"
 #include "floatComplex.h"
 #include "doubleComplex.h"
+#include "types.h"
 
 #ifdef  __cplusplus
 extern "C" {
@@ -34,6 +35,18 @@ EXTERN_MATOPS float cmagna(floatComplex* in, int rows, int cols);
 EXTERN_MATOPS double zmagns(doubleComplex in);
 EXTERN_MATOPS double zmagna(doubleComplex* in, int rows, int cols);
 
+EXTERN_MATOPS uint8 u8magns(uint8 in);
+EXTERN_MATOPS uint8 u8magna(uint8* in, int rows, int cols);
+
+EXTERN_MATOPS uint16 u16magns(uint16 in);
+EXTERN_MATOPS uint16 u16magna(uint16* in, int rows, int cols);
+
+EXTERN_MATOPS int8 i8magns(int8 in);
+EXTERN_MATOPS int8 i8magna(int8* in, int rows, int cols);
+
+EXTERN_MATOPS int16 i16magns(int16 in);
+EXTERN_MATOPS int16 i16magna(int16* in, int rows, int cols);
+
 #ifdef  __cplusplus
 } /* extern "C" */
 #endif
diff --git a/2.3-1/src/c/matrixOperations/includes/matrixMultiplication.h b/2.3-1/src/c/matrixOperations/includes/matrixMultiplication.h
index 228dd163..c2235c8b 100644
--- a/2.3-1/src/c/matrixOperations/includes/matrixMultiplication.h
+++ b/2.3-1/src/c/matrixOperations/includes/matrixMultiplication.h
@@ -16,6 +16,7 @@
 #include "dynlib_matrixoperations.h"
 #include "multiplication.h"
 #include "addition.h"
+#include "types.h"
 
 #ifdef  __cplusplus
 extern "C" {
@@ -84,6 +85,64 @@ EXTERN_MATOPS void	zmulma(doubleComplex *in1, int lines1, int columns1,
 	       doubleComplex *in2, int lines2, int columns2,
 	       doubleComplex *out);
 
+/*
+** \brief Compute a multiplication for uint8 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+EXTERN_MATOPS void	u8mulma(uint8 *in1, int lines1, int columns1,
+	       uint8 *in2, int lines2, int columns2,
+	       uint8 *out);
+
+/*
+** \brief Compute a multiplication for uint16 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+EXTERN_MATOPS void	u16mulma(uint16 *in1, int lines1, int columns1,
+	       uint16 *in2, int lines2, int columns2,
+	       uint16 *out);
+
+/*
+** \brief Compute a multiplication for int8 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+EXTERN_MATOPS void	i8mulma(int8 *in1, int lines1, int columns1,
+	       int8 *in2, int lines2, int columns2,
+	       int8 *out);
+
+/*
+** \brief Compute a multiplication for int16 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+EXTERN_MATOPS void	i16mulma(int16 *in1, int lines1, int columns1,
+	       int16 *in2, int lines2, int columns2,
+	       int16 *out);
+
+
+
 #ifdef  __cplusplus
 } /* extern "C" */
 #endif
diff --git a/2.3-1/src/c/matrixOperations/interfaces/int_OpStar.h b/2.3-1/src/c/matrixOperations/interfaces/int_OpStar.h
index 400918a4..f922b319 100644
--- a/2.3-1/src/c/matrixOperations/interfaces/int_OpStar.h
+++ b/2.3-1/src/c/matrixOperations/interfaces/int_OpStar.h
@@ -23,6 +23,14 @@
 
 #define c2c2OpStarc2(in1,size1,in2,size2,out)		cmulma(in1,size1[0],size1[1],in2,size2[0],size2[1],out)
 
+#define u82u82OpStaru82(in1,size1,in2,size2,out)	u8mulma(in1,size1[0],size1[1],in2,size2[0],size2[1],out)
+
+#define u162u162OpStaru162(in1,size1,in2,size2,out)	u16mulma(in1,size1[0],size1[1],in2,size2[0],size2[1],out)
+
+#define i82i82OpStari82(in1,size1,in2,size2,out)	i8mulma(in1,size1[0],size1[1],in2,size2[0],size2[1],out)
+
+#define i162i162OpStari162(in1,size1,in2,size2,out)	i16mulma(in1,size1[0],size1[1],in2,size2[0],size2[1],out)
+
 #define c2s2OpStarc2(in1,size1,in2,size2,out)		cmulma(in1,size1[0],size1[1],FloatComplexMatrix(in2,0,size2[0]*size2[1]),size2[0],size2[1],out)
 
 #define s2c2OpStarc2(in1,size1,in2,size2,out)		cmulma(FloatComplexMatrix(in1,0,size1[0]*size1[1]),size1[0],size1[1],in2,size2[0],size2[1],out)
diff --git a/2.3-1/src/c/matrixOperations/interfaces/int_cat.h b/2.3-1/src/c/matrixOperations/interfaces/int_cat.h
new file mode 100644
index 00000000..7b3107a8
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/interfaces/int_cat.h
@@ -0,0 +1,349 @@
+/* Scilab2C FOSSEE IIT BOMBAY */
+
+#ifndef __INT_CAT_H
+#define __INT_CAT_H
+
+/* Column Cat */
+
+/* Same input elements */
+
+#define s0s0cats2(in1,in2,out)					scolumncats(in1,in2,out)
+		
+#define d0d0catd2(in1,in2,out)					dcolumncats(in1,in2,out)
+
+#define c0c0catc2(in1,in2,out)					ccolumncats(in1,in2,out)
+
+#define z0z0catz2(in1,in2,out)					zcolumncats(in1,in2,out)
+
+#define u80u80catu82(in1,in2,out)                              u8columncats(in1,in2,out)
+
+#define u160u160catu162(in1,in2,out)                           u16columncats(in1,in2,out)
+
+#define i80i80cati82(in1,in2,out)                              i8columnscats(in1,in2,out)
+
+#define i160i160cati162(in1,in2,out)                           i16columnscats(in1,in2,out)
+
+#define s2s2cats2(in1,size1,in2,size2,out)			scolumncata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define d2d2catd2(in1,size1,in2,size2,out)			dcolumncata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+/* ROW COLUMN SUPPORT for cat, If First argument in cat command is 1 then it will concatenate the element ROW WISE else COLUMN WISE */
+
+#define d0d2d2catd2(in1,in2,size2,in3,size3,out)                (in1 == 1) ? drowcata(in2, size2[0], size2[1], in3, size3[0], size3[1], out) : dcolumncata(in2, size2[0],size2[1],in3,size3[0],size3[1],out)
+
+#define d0u82u82catu82(in1,in2,size2,in3,size3,out)                (in1 == 1) ? u8rowcata(in2, size2[0], size2[1], in3, size3[0], size3[1], out) : u8columncata(in2, size2[0],size2[1],in3,size3[0],size3[1],out)
+
+#define d0u162u162catu162(in1,in2,size2,in3,size3,out)                (in1 == 1) ? u16rowcata(in2, size2[0], size2[1], in3, size3[0], size3[1], out) : u16columncata(in2, size2[0],size2[1],in3,size3[0],size3[1],out)
+
+
+#define d0i82i82cati82(in1,in2,size2,in3,size3,out)                (in1 == 1) ? i8rowcata(in2, size2[0], size2[1], in3, size3[0], size3[1], out) : i8columncata(in2, size2[0],size2[1],in3,size3[0],size3[1],out)
+
+#define d0i162i162cati162(in1,in2,size2,in3,size3,out)                (in1 == 1) ? i16rowcata(in2, size2[0], size2[1], in3, size3[0], size3[1], out) : i16columncata(in2, size2[0],size2[1],in3,size3[0],size3[1],out)
+
+
+#define c2c2catc2(in1,size1,in2,size2,out)			ccolumncata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define z2z2catz2(in1,size1,in2,size2,out)			zcolumncata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define u82u82catu82(in1,size1,in2,size2,out)                  u8columncata(in1,size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define u162u162catu162(in1,size1,in2,size2,out)               u16columncata(in1,size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define i82i82cati82(in1,size1,in2,size2,out)                  i8columncata(in1,size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define i162i162cati162(in1,size1,in2,size2,out)               i16columncata(in1,size1[0], size1[1], in2, size2[0], size2[1], out)
+
+
+
+/* Differents input elements */
+#define s0c0catc2(in1,in2,out)					c0c0OpRcc2(FloatComplex(in1,0),in2,out)
+		
+#define d0z0catz2(in1,in2,out)					z0z0OpRcz2(DoubleComplex(in1,0),in2,out)
+
+#define c0s0catc2(in1,in2,out)					c0c0OpRcc2(in1,FloatComplex(in2,0),out)
+
+#define z0d0catz2(in1,in2,out)					z0z0OpRcz2(in1,DoubleComplex(in2,0),out)
+
+#define s2c2catc2(in1,size1,in2,size2,out)			sfilla((float*)out,size1[0],size1[1],0); \
+										c2c2OpRcc2(FloatComplexMatrix(in1,(float*)out,size1[0]*size1[1]), size1, in2, size2, out)
+
+#define d2z2catz2(in1,size1,in2,size2,out)			dfilla((double*)out,size1[0],size1[1],0);  \
+										z2z2OpRcz2(DoubleComplexMatrix(in1,(double*)out,size1[0]*size1[1]), size1, in2, size2, out)
+
+#define c2s2catc2(in1,size1,in2,size2,out)			sfilla((float*)out,size2[0],size2[1],0);  \
+										c2c2OpRcc2(in1, size1, FloatComplexMatrix(in2,(float*)out,size2[0]*size2[1]), size2, out)
+
+#define z2d2catz2(in1,size1,in2,size2,out)			dfilla((double*)out,size2[0],size2[1],0);  \
+										z2z2OpRcz2(in1, size1, DoubleComplexMatrix(in2,(double*)out,size2[0]*size2[1]), size2, out)
+
+/* Matrix-Scalar */
+
+/* Same type */
+
+#define s2s0cats2(in1,size,in2,out)				{ float temp=in2; \
+										  scolumncata(in1, size[0], size[1],&temp, 1, 1, out); \
+										}
+
+#define d2d0catd2(in1,size,in2,out)				{ double temp=in2; \
+										  dcolumncata(in1, size[0], size[1],&temp, 1, 1, out); \
+										}
+										
+#define c2c0catc2(in1,size,in2,out)				{ floatComplex temp=in2; \
+										 ccolumncata(in1, size[0], size[1], &temp, 1, 1, out); \
+										}
+
+#define z2z0catz2(in1,size,in2,out)				{ doubleComplex temp=in2; \
+										 zcolumncata(in1, size[0], size[1], &temp, 1, 1, out); \
+										}
+
+#define u82u80catu82(in1,size,in2,out)                         { uint8 temp=in2; \
+                                                                                 u8columncata(in1,size[0],size[1],&temp,1,1,out); \
+                                                                                }
+#define u162u160catu162(in1,size,in2,out)                      { uint16 temp=in2; \
+                                                                                  u16columncata(in1,size[0],size[1],&temp,1,1,out); \
+                                                                                }
+#define i82i80cati82(in1,size,in2,out)                         { int8 temp=in2; \
+                                                                                 i8columncata(in1,size[0],size[1],&temp,1,1,out); \
+                                                                                }
+#define i162i160cati162(in1,size,in2,out)                      { int16 temp=in2; \
+                                                                                  i16columncata(in1,size[0],size[1],&temp,1,1,out); \
+                                                                                }
+
+
+/* Different type */
+#define s2c0catc2(in1,size,in2,out)				{ floatComplex temp=in2; \
+										sfilla((float *)out,size[0],size[1],0);  \
+										scolumncata(FloatComplexMatrix(in1,(float*)out,size[0]*size[1]), size[0], size[1], &temp , 1, 1, out); \
+										}
+
+#define d2z0catz2(in1,size,in2,out)				{ doubleComplex temp=in2; \
+										dfilla((double *)out,size[0],size[1],0);  \
+										zcolumncata(DoubleComplexMatrix(in1,(double *)out,size[0]*size[1]), size[0], size[1], &temp , 1, 1, out); \
+										}
+
+#define c2s0catc2(in1,size,in2,out)				{ floatComplex temp = FloatComplex(in2,0);   \
+										  ccolumncata(in1, size[0], size[1], &temp, 1, 1, out); \
+										}
+
+#define z2d0catz2(in1,size,in2,out)				{ doubleComplex temp = DoubleComplex(in2,0);   \
+										   zcolumncata(in1, size[0], size[1], &temp, 1, 1, out); \
+										}
+
+/* Scalar-Matrix */
+
+/* Same type */
+#define s0s2cats2(in1,in2,size,out)				{ \
+ float __tmp1 = in1 ;\
+ scolumncata(&__tmp1 , 1, 1, in2, size[0], size[1], out);\
+}
+#define d0d2catd2(in1,in2,size,out)				{\
+ double __tmp1 = in1 ;\
+ dcolumncata(&__tmp1 , 1, 1, in2, size[0], size[1], out); \
+}
+
+#define c0c2catc2(in1,in2,size,out)				{ \
+ floatComplex __tmp1 = in1 ;\
+ ccolumncata(&__tmp1, 1, 1, in2, size[0], size[1], out);\
+}
+
+#define z0z2catz2(in1,in2,size,out)				{ \
+ doubleComplex  __tmp1 = in1 ;\
+ zcolumncata(&__tmp1, 1, 1, in2, size[0], size[1], out);\
+}
+
+#define u80u82catu82(in1,in2,size,out)                         {\
+ uint8 __tmp1 = in1 ;\
+ u8columncata(&__tmp1,1,1,in2,size[0],size[1],out);\
+}
+
+#define u160u162catu162(in1,in2,size,out)                         {\
+ uint16 __tmp1 = in1 ;\
+ u16columncata(&__tmp1,1,1,in2,size[0],size[1],out);\
+}
+
+#define i80i82cati82(in1,in2,size,out)                         {\
+ int8 __tmp1 = in1 ;\
+ i8columncata(&__tmp1,1,1,in2,size[0],size[1],out);\
+}
+
+#define i160i162cati162(in1,in2,size,out)                         {\
+ int16 __tmp1 = in1 ;\
+ i16columncata(&__tmp1,1,1,in2,size[0],size[1],out);\
+}
+
+
+/* Different type */
+#define s0c2catc2(in1,in2,size,out)				c0c2OpRcc2(FloatComplex(in1,0),in2,size,out)
+
+#define d0z2catz2(in1,in2,size,out)				z0z2OpRcz2(DoubleComplex(in1,0),in2,size,out)
+
+#define c0s2catc2(in1,in2,size,out)				sfilla((float*)out,size[0],size[1],0); \
+										c0c2OpRcc2(in1,FloatComplexMatrix(in2,(float*)out,size[0]*size[1]),size,out)
+
+#define z0d2catz2(in1,in2,size,out)				dfilla((double*)out,size[0],size[1],0);  \
+										z0z2OpRcz2(in1,DoubleComplexMatrix(in2,(double*)out,size[0]*size[1]),size,out)
+
+
+/* Column Cat */
+
+/* Same input elements */
+
+#define s0s0cats2(in1,in2,out)					srowcats(in1,in2,out)
+		
+#define d0d0catd2(in1,in2,out)					drowcats(in1,in2,out)
+
+#define c0c0catc2(in1,in2,out)					crowcats(in1,in2,out)
+
+#define z0z0catz2(in1,in2,out)					zrowcats(in1,in2,out)
+
+#define u80u80catu82(in1,in2,out)                              u8rowcats(in1,in2,out)
+
+#define u160u160catu162(in1,in2,out)                           u16rowcats(in1,in2,out)
+
+#define i80i80cati82(in1,in2,out)                              i8rowcats(in1,in2,out)
+
+#define i160i160cati162(in1,in2,out)                           i16rowcats(in1,in2,out)
+
+#define s2s2cats2(in1,size1,in2,size2,out)			srowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define d2d2catd2(in1,size1,in2,size2,out)			drowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define c2c2catc2(in1,size1,in2,size2,out)			crowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define z2z2catz2(in1,size1,in2,size2,out)			zrowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define u82u82catu82(in1,size1,in2,size2,out)                  u8rowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define u162u162catu162(in1,size1,in2,size2,out)               u16rowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define i82i82cati82(in1,size1,in2,size2,out)                  i8rowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+#define i162i162cati162(in1,size1,in2,size2,out)               i16rowcata(in1, size1[0], size1[1], in2, size2[0], size2[1], out)
+
+/* Differents input elements */
+#define s0c0catc2(in1,in2,out)					c0c0OpCcc2(FloatComplex(in1,0),in2,out)
+		
+#define d0z0catz2(in1,in2,out)					z0z0OpCcz2(DoubleComplex(in1,0),in2,out)
+
+#define c0s0catc2(in1,in2,out)					c0c0OpCcc2(in1,FloatComplex(in2,0),out)
+
+#define z0d0catz2(in1,in2,out)					z0z0OpCcz2(in1,DoubleComplex(in2,0),out)
+
+#define s2c2catc2(in1,size1,in2,size2,out)			sfilla((float*)out,size1[0],size1[1],0); \
+										c2c2OpCcc2(FloatComplexMatrix(in1,(float*)out,size1[0]*size1[1]), size1, in2, size2, out)
+
+#define d2z2catz2(in1,size1,in2,size2,out)			dfilla((double*)out,size1[0],size1[1],0);  \
+										z2z2OpCcz2(DoubleComplexMatrix(in1,(double*)out,size1[0]*size1[1]), size1, in2, size2, out)
+
+#define c2s2catc2(in1,size1,in2,size2,out)			sfilla((float*)out,size2[0],size2[1],0);  \
+										c2c2OpCcc2(in1, size1, FloatComplexMatrix(in2,(float*)out,size2[0]*size2[1]), size2, out)
+
+#define z2d2catz2(in1,size1,in2,size2,out)			dfilla((double*)out,size2[0],size2[1],0); \
+										z2z2OpCcz2(in1, size1, DoubleComplexMatrix(in2,(double*)out,size2[0]*size2[1]), size2, out)
+
+/* Matrix-Scalar */
+
+/* Same type */
+
+#define s2s0cats2(in1,size,in2,out)				{ float temp=in2; \
+										  srowcata(in1, size[0], size[1],&temp, 1, 1, out); \
+										}
+
+#define d2d0catd2(in1,size,in2,out)				{ double temp=in2; \
+										  drowcata(in1, size[0], size[1],&temp, 1, 1, out); \
+										}
+
+#define c2c0catc2(in1,size,in2,out)				{ floatComplex temp = in2;   \
+										  crowcata(in1, size[0], size[1],&temp, 1, 1, out);\
+										}
+
+#define z2z0catz2(in1,size,in2,out)				{ doubleComplex temp =in2;   \
+										  zrowcata(in1, size[0], size[1],&temp, 1, 1, out);\
+								}
+
+#define u82u80catu82(in1,size,in2,out)                         { uint8 temp=in2; \
+                                                                                 u8rowcata(in1, size[0], size[1],&temp, 1,1,out);\
+                                                                }
+#define u162u160catu162(in1,size,in2,out)                      { uint16 temp=in2; \
+                                                                                 u16rowcata(in1, size[0], size[1],&temp, 1,1,out);\
+                                                                }
+
+#define i82i80cati82(in1,size,in2,out)                         { int8 temp=in2; \
+                                                                                 i8rowcata(in1, size[0], size[1],&temp, 1,1,out);\
+                                                                }
+#define i162i160cati162(in1,size,in2,out)                      { int16 temp=in2; \
+                                                                                 i16rowcata(in1, size[0], size[1],&temp, 1,1,out);\
+                                                                }
+
+
+
+/* Different type */
+#define s2c0catc2(in1,size,in2,out)				sfilla((float *)out,size[0],size[1],0); \
+										c2c0OpCcc2(FloatComplexMatrix(in1,(float*)out,size[0]*size[1]),size,in2,out)
+
+#define d2z0catz2(in1,size,in2,out)				dfilla((double *)out,size[0],size[1],0); \
+										z2z0OpCcz2(DoubleComplexMatrix(in1,(double *)out,size[0]*size[1]),size,in2,out)
+
+#define c2s0catc2(in1,size,in2,out)				{ floatComplex temp = FloatComplex(in2, 0); 	c2c0OpCcc2(in1, size, temp, out)}
+
+#define z2d0catz2(in1,size,in2,out)				{ doubleComplex temp = DoubleComplex(in2, 0); 	z2z0OpCcz2(in1, size, temp, out)}
+					
+
+/* Scalar-Matrix */
+
+/* Same type */
+#define s0s2cats2(in1,in2,size,out)				{ \
+ float __tmp1 = in1 ;\
+ srowcata(&__tmp1, 1, 1, in2, size[0], size[1], out);\
+}
+
+#define d0d2catd2(in1,in2,size,out)				{ \
+ double __tmp1 = in1 ;\
+ drowcata(&__tmp1, 1, 1, in2, size[0], size[1], out);\
+}
+
+#define c0c2catc2(in1,in2,size,out)				{ \
+ floatComplex __tmp1 = in1 ;\
+ crowcata(&__tmp1, 1, 1, in2, size[0], size[1], out);\
+}
+
+#define z0z2catz2(in1,in2,size,out)				{ \
+ doubleComplex __tmp1 = in1 ;\
+ zrowcata(&__tmp1, 1, 1, in2, size[0], size[1], out);\
+}
+
+#define u80u82catu82(in1,in2,size,out)                         { \
+  uint8 __tmp1 = in1;\
+  u8rowcata(&__tmp1, 1,1, in2, size[0], size[1], out);\
+}
+
+#define u160u162catu162(in1,in2,size,out)                         { \
+  uint16 __tmp1 = in1;\
+  u16rowcata(&__tmp1, 1,1, in2, size[0], size[1], out);\
+}
+
+#define i80i82cati82(in1,in2,size,out)                         { \
+  int8 __tmp1 = in1;\
+  i8rowcata(&__tmp1, 1,1, in2, size[0], size[1], out);\
+}
+
+#define i160i162cati162(in1,in2,size,out)                         { \
+  int16 __tmp1 = in1;\
+  i16rowcata(&__tmp1, 1,1, in2, size[0], size[1], out);\
+}
+
+
+/* Different type */
+#define s0c2catc2(in1,in2,size,out)				c0c2OpCcc2(FloatComplex(in1,0),in2,size,out)
+
+#define d0z2catz2(in1,in2,size,out)				z0z2OpCcz2(DoubleComplex(in1,0),in2,size,out)
+
+#define c0s2catc2(in1,in2,size,out)				sfilla((float*)out,size[0],size[1],0); \
+										c0c2OpCcc2(in1,FloatComplexMatrix(in2,(float*)out,size[0]*size[1]),size,out)
+
+#define z0d2catz2(in1,in2,size,out)				dfilla((double*)out,size[0],size[1],0);  \
+										z0z2OpCcz2(in1,DoubleComplexMatrix(in2,(double*)out,size[0]*size[1]),size,out)
+
+
+#endif /* !__INT_CAT__H */
+
diff --git a/2.3-1/src/c/matrixOperations/interfaces/int_vmagn.h b/2.3-1/src/c/matrixOperations/interfaces/int_vmagn.h
index 8a51755e..a8647aa2 100644
--- a/2.3-1/src/c/matrixOperations/interfaces/int_vmagn.h
+++ b/2.3-1/src/c/matrixOperations/interfaces/int_vmagn.h
@@ -24,6 +24,14 @@
 
 #define z0vmagnz0(in)			zmagns(in)
 
+#define u80vmagnu80(in)                 u8magns(in)
+
+#define u160vmagnu160(in)               u16magns(in)
+
+#define i80vmagni80(in)                 i8magns(in)
+
+#define i160vmagni160(in)               i16magns(in)
+
 #define s2vmagns2(in,size)		smagna(in, size[0], size[1])
 
 #define d2vmagnd2(in,size)		dmagna(in, size[0], size[1])
@@ -32,4 +40,12 @@
 
 #define z2vmagnz2(in,size)		zmagna(in, size[0], size[1])
 
+#define u82vmagnu82(in,size)            u8magna(in, size[0], size[1])
+
+#define u162vmagnu162(in,size)          u16magna(in, size[0], size[1])
+
+#define i82vmagni82(in,size)            i8magna(in, size[0], size[1])
+
+#define i162vmagni162(in,size)          i16magna(in, size[0], size[1])
+
 #endif /* !__INT_VMAGN_H__ */
diff --git a/2.3-1/src/c/matrixOperations/magnitude/i16magna.c b/2.3-1/src/c/matrixOperations/magnitude/i16magna.c
new file mode 100644
index 00000000..884a278e
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/i16magna.c
@@ -0,0 +1,33 @@
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+
+int16 i16magna(int16* in, int rows, int cols){
+	int i=0,j=0;
+	int16  out=0, colSum=0;
+	
+	/* Other method : 
+		drowsuma(in,rows,cols,temp);
+		out=max(temp,cols);
+	but we have to malloc a array */
+		
+	if ((rows==1)||(cols==1)){
+		for(i=0;i<cols*rows;i++){
+			out += dmagns(in[i]);
+		}
+	}
+	else{		
+		for(i=0;i<cols;i++){
+			colSum = 0;
+			for(j=0;j<rows;j++){
+				colSum += dmagns(in[i*rows+j]);
+			}
+			if (colSum>out) out=colSum;
+		}
+	}
+	return out;
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/magnitude/i16magns.c b/2.3-1/src/c/matrixOperations/magnitude/i16magns.c
new file mode 100644
index 00000000..d5deb28a
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/i16magns.c
@@ -0,0 +1,13 @@
+
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+#include "abs.h"
+
+int16 i16magns(int16 in){
+	return i16abss(in);
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/magnitude/i8magna.c b/2.3-1/src/c/matrixOperations/magnitude/i8magna.c
new file mode 100644
index 00000000..1a8519a8
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/i8magna.c
@@ -0,0 +1,33 @@
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+
+int8 i8magna(int8* in, int rows, int cols){
+	int i=0,j=0;
+	int8  out=0, colSum=0;
+	
+	/* Other method : 
+		drowsuma(in,rows,cols,temp);
+		out=max(temp,cols);
+	but we have to malloc a array */
+		
+	if ((rows==1)||(cols==1)){
+		for(i=0;i<cols*rows;i++){
+			out += dmagns(in[i]);
+		}
+	}
+	else{		
+		for(i=0;i<cols;i++){
+			colSum = 0;
+			for(j=0;j<rows;j++){
+				colSum += dmagns(in[i*rows+j]);
+			}
+			if (colSum>out) out=colSum;
+		}
+	}
+	return out;
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/magnitude/i8magns.c b/2.3-1/src/c/matrixOperations/magnitude/i8magns.c
new file mode 100644
index 00000000..1703505d
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/i8magns.c
@@ -0,0 +1,13 @@
+
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+#include "abs.h"
+
+int8 i8magns(int8 in){
+	return i8abss(in);
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/magnitude/u16magna.c b/2.3-1/src/c/matrixOperations/magnitude/u16magna.c
new file mode 100644
index 00000000..10680c77
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/u16magna.c
@@ -0,0 +1,33 @@
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+
+uint16 u16magna(uint16* in, int rows, int cols){
+	int i=0,j=0;
+	uint16  out=0, colSum=0;
+	
+	/* Other method : 
+		drowsuma(in,rows,cols,temp);
+		out=max(temp,cols);
+	but we have to malloc a array */
+		
+	if ((rows==1)||(cols==1)){
+		for(i=0;i<cols*rows;i++){
+			out += dmagns(in[i]);
+		}
+	}
+	else{		
+		for(i=0;i<cols;i++){
+			colSum = 0;
+			for(j=0;j<rows;j++){
+				colSum += dmagns(in[i*rows+j]);
+			}
+			if (colSum>out) out=colSum;
+		}
+	}
+	return out;
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/magnitude/u16magns.c b/2.3-1/src/c/matrixOperations/magnitude/u16magns.c
new file mode 100644
index 00000000..78853edc
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/u16magns.c
@@ -0,0 +1,13 @@
+
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+#include "abs.h"
+
+uint16 u16magns(uint16 in){
+	return u16abss(in);
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/magnitude/u8magna.c b/2.3-1/src/c/matrixOperations/magnitude/u8magna.c
new file mode 100644
index 00000000..7f5df582
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/u8magna.c
@@ -0,0 +1,33 @@
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+
+uint8 u8magna(uint8* in, int rows, int cols){
+	int i=0,j=0;
+	uint8  out=0, colSum=0;
+	
+	/* Other method : 
+		drowsuma(in,rows,cols,temp);
+		out=max(temp,cols);
+	but we have to malloc a array */
+		
+	if ((rows==1)||(cols==1)){
+		for(i=0;i<cols*rows;i++){
+			out += dmagns(in[i]);
+		}
+	}
+	else{		
+		for(i=0;i<cols;i++){
+			colSum = 0;
+			for(j=0;j<rows;j++){
+				colSum += dmagns(in[i*rows+j]);
+			}
+			if (colSum>out) out=colSum;
+		}
+	}
+	return out;
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/magnitude/u8magns.c b/2.3-1/src/c/matrixOperations/magnitude/u8magns.c
new file mode 100644
index 00000000..e6d789ca
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/magnitude/u8magns.c
@@ -0,0 +1,13 @@
+
+/* SCilab2C FOSSEE IIT BOMBAY */
+
+
+
+#include "matrixMagnitude.h"
+#include "abs.h"
+
+uint8 u8magns(uint8 in){
+	return u8abss(in);
+}
+
+
diff --git a/2.3-1/src/c/matrixOperations/multiplication/i16mulma.c b/2.3-1/src/c/matrixOperations/multiplication/i16mulma.c
new file mode 100644
index 00000000..ee1268a4
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/multiplication/i16mulma.c
@@ -0,0 +1,44 @@
+/*SCilab2C FOSSEE IIT Bombay*/
+
+/*
+** \brief Compute a multiplication for int16 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+
+// dgemm function of lapack library does not support uint8,uint16,int8 and int16 datatype so removed
+
+#include "matrixMultiplication.h"
+
+void i16mulma(int16 *in1,int lines1,int columns1,
+             int16 *in2,int lines2,int columns2,
+             int16 *out)
+{
+
+  /* Do Not Use Any BLAS Function*/
+  int i = 0;
+  int k = 0;
+  int16 accu = 0;
+  
+  /* How to convert 2 index matrixes to  one.
+  ** #define in1(a,b) in1[a+b*lines1]
+  ** #define in2(c,d) in2[c+d*lines2]
+  */
+  for(i=0;i < lines1 * columns2; ++i)
+  {  
+    accu = 0;
+    for(k=0;k < columns1; ++k)
+    {  
+      accu += in1[i % lines1 + k * lines1] * in2[k + (i / lines1) * lines2];
+
+    }
+    out[i] = accu;
+  
+  }
+
+}
diff --git a/2.3-1/src/c/matrixOperations/multiplication/i8mulma.c b/2.3-1/src/c/matrixOperations/multiplication/i8mulma.c
new file mode 100644
index 00000000..0efe797e
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/multiplication/i8mulma.c
@@ -0,0 +1,44 @@
+/*SCilab2C FOSSEE IIT Bombay*/
+
+/*
+** \brief Compute a multiplication for int8 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+
+// dgemm function of lapack library does not support uint8,uint16,int8 and int16 datatype so removed
+
+#include "matrixMultiplication.h"
+
+void i8mulma(int8 *in1,int lines1,int columns1,
+             int8 *in2,int lines2,int columns2,
+             int8 *out)
+{
+
+  /* Do Not Use Any BLAS Function*/
+  int i = 0;
+  int k = 0;
+  int8 accu = 0;
+  
+  /* How to convert 2 index matrixes to  one.
+  ** #define in1(a,b) in1[a+b*lines1]
+  ** #define in2(c,d) in2[c+d*lines2]
+  */
+  for(i=0;i < lines1 * columns2; ++i)
+  {  
+    accu = 0;
+    for(k=0;k < columns1; ++k)
+    {  
+      accu += in1[i % lines1 + k * lines1] * in2[k + (i / lines1) * lines2];
+
+    }
+    out[i] = accu;
+  
+  }
+
+}
diff --git a/2.3-1/src/c/matrixOperations/multiplication/u16mulma.c b/2.3-1/src/c/matrixOperations/multiplication/u16mulma.c
new file mode 100644
index 00000000..a36c57c7
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/multiplication/u16mulma.c
@@ -0,0 +1,44 @@
+/*SCilab2C FOSSEE IIT Bombay*/
+
+/*
+** \brief Compute a multiplication for uint16 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+
+// dgemm function of lapack library does not support uint8,uint16,int8 and int16 datatype so removed
+
+#include "matrixMultiplication.h"
+
+void u16mulma(uint16 *in1,int lines1,int columns1,
+             uint16 *in2,int lines2,int columns2,
+             uint16 *out)
+{
+
+  /* Do Not Use Any BLAS Function*/
+  int i = 0;
+  int k = 0;
+  uint16 accu = 0;
+  
+  /* How to convert 2 index matrixes to  one.
+  ** #define in1(a,b) in1[a+b*lines1]
+  ** #define in2(c,d) in2[c+d*lines2]
+  */
+  for(i=0;i < lines1 * columns2; ++i)
+  {  
+    accu = 0;
+    for(k=0;k < columns1; ++k)
+    {  
+      accu += in1[i % lines1 + k * lines1] * in2[k + (i / lines1) * lines2];
+
+    }
+    out[i] = accu;
+  
+  }
+
+}
diff --git a/2.3-1/src/c/matrixOperations/multiplication/u8mulma.c b/2.3-1/src/c/matrixOperations/multiplication/u8mulma.c
new file mode 100644
index 00000000..ea630b6f
--- /dev/null
+++ b/2.3-1/src/c/matrixOperations/multiplication/u8mulma.c
@@ -0,0 +1,44 @@
+/*SCilab2C FOSSEE IIT Bombay*/
+
+/*
+** \brief Compute a multiplication for uint8 matrixes.
+** \param in1 : input matrix.
+** \param lines1 : lines of in1 matrix.
+** \param columns1 : columns of in1 matrix.
+** \param in2 : input arry.
+** \param lines2 : lines of in2 matrix.
+** \param columns2 : columns of in2 matrix.
+** \param out : Matrix that contains the multiplication in1 * in2.
+*/
+
+
+// dgemm function of lapack library does not support uint8,uint16,int8 and int16 datatype so removed
+
+#include "matrixMultiplication.h"
+
+void u8mulma(uint8 *in1,int lines1,int columns1,
+             uint8 *in2,int lines2,int columns2,
+             uint8 *out)
+{
+
+  int i = 0;
+  int k = 0;
+  uint8 accu = 0;
+  
+  /* How to convert 2 index matrixes to  one.
+  ** #define in1(a,b) in1[a+b*lines1]
+  ** #define in2(c,d) in2[c+d*lines2]
+  */
+  for(i=0;i < lines1 * columns2; ++i)
+  {  
+    accu = 0;
+    for(k=0;k < columns1; ++k)
+    {  
+      accu += in1[i % lines1 + k * lines1] * in2[k + (i / lines1) * lines2];
+
+    }
+    out[i] = accu;
+      
+  }
+
+}