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

42 files changed, 1638 insertions, 1 deletions

diff --git a/2.3-1/macros/FunctionAnnotation/FA_SZ_ROW_COLUMN_CAT.sci b/2.3-1/macros/FunctionAnnotation/FA_SZ_ROW_COLUMN_CAT.sci
new file mode 100644
index 00000000..5ab0c649
--- /dev/null
+++ b/2.3-1/macros/FunctionAnnotation/FA_SZ_ROW_COLUMN_CAT.sci
@@ -0,0 +1,23 @@
+function outsize = FA_SZ_ROW_COLUMN_CAT(inval,in1size,in2size)

+

+

+//Check the input arguments

+SCI2CNInArgCheck(argn(2),3,3);

+in1size = string(in1size);

+in2size = string(in2size);

+inval = string(inval);

+if(inval == '1') then

+    in1num_r = eval(in1size);

+    in2num_r = eval(in2size);

+    outsize(1) = string(in1num_r + in2num_r);

+    outsize(2) = string(in2num_r);

+elseif(inval == '2') then

+    in1num_c = eval(in1size);

+    in2num_c = eval(in2size)

+    outsize(1) = string(in1num_c);

+    outsize(2) = string(in1num_c + in2num_c);

+else

+     error(36, "Wrong input argument '+inval+'. Use 1 or 2 as first argument in cat command.");

+end

+

+endfunction 

diff --git a/2.3-1/macros/ToolInitialization/INIT_FillSCI2LibCDirs.sci b/2.3-1/macros/ToolInitialization/INIT_FillSCI2LibCDirs.sci
index 4aff7b74..629b3ee8 100644
--- a/2.3-1/macros/ToolInitialization/INIT_FillSCI2LibCDirs.sci
+++ b/2.3-1/macros/ToolInitialization/INIT_FillSCI2LibCDirs.sci
@@ -2119,6 +2119,98 @@ INIT_GenAnnFLFunctions(FunctionName,SCI2CLibCFLFunDir,ClassName,GeneralReport,Ex
 

 

 // -------------------

+// --- Class cat. ---

+// -------------------

+ClassName = 'cat';

+

+// --- Class Annotation. ---

+PrintStringInfo('   Adding Class: '+ClassName+'.',GeneralReport,'file','y');

+ClassFileName = fullfile(SCI2CLibCAnnClsDir,ClassName+ExtensionCAnnCls);

+PrintStringInfo('NIN=          3',ClassFileName,'file','y');

+PrintStringInfo('NOUT=         1',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).TP=    FA_TP_MAX(IN(2).TP,IN(3).TP)',ClassFileName,'file','y');

+//PrintStringInfo('OUT(1).SZ(1)= FA_ADD(IN(2).SZ(1),IN(3).SZ(1))',ClassFileName,'file','y');

+//PrintStringInfo('OUT(1).SZ(2)= FA_ADD(IN(2).SZ(2),IN(3).SZ(2))',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).SZ(1)= FA_SZ_1(FA_SZ_ROW_COLUMN_CAT(IN(1).VAL,IN(2).SZ(1),IN(3).SZ(1)))',ClassFileName,'file','y');

+PrintStringInfo('OUT(1).SZ(2)= FA_SZ_2(FA_SZ_ROW_COLUMN_CAT(IN(1).VAL,IN(2).SZ(2),IN(3).SZ(2)))',ClassFileName,'file','y');

+//PrintStringInfo('OUT(1).SZ(1)= FA_SZ_ROW_COLUMN_CAT(IN(1).VAL,IN(2).SZ(1),IN(3).SZ(1))',ClassFileName,'file','y');

+//PrintStringInfo('OUT(1).SZ(2)= FA_SZ_ROW_COLUMN_CAT(IN(1).VAL,IN(2).SZ(2),IN(3).SZ(2))',ClassFileName,'file','y');

+

+

+// --- Function List Class. ---

+//NUT: no mixed data types considered

+ClassFileName = fullfile(SCI2CLibCFLClsDir,ClassName+ExtensionCFuncListCls);

+PrintStringInfo('s0s0'+ArgSeparator+'s2',ClassFileName,'file','y');

+PrintStringInfo('s0s2'+ArgSeparator+'s2',ClassFileName,'file','y');

+PrintStringInfo('s2s0'+ArgSeparator+'s2',ClassFileName,'file','y');

+PrintStringInfo('s2s2'+ArgSeparator+'s2',ClassFileName,'file','y');

+

+PrintStringInfo('d0d0'+ArgSeparator+'d2',ClassFileName,'file','y');

+PrintStringInfo('d0d2'+ArgSeparator+'d2',ClassFileName,'file','y');

+PrintStringInfo('d2d0'+ArgSeparator+'d2',ClassFileName,'file','y');

+PrintStringInfo('d2d2'+ArgSeparator+'d2',ClassFileName,'file','y');

+PrintStringInfo('d0d2d2' +ArgSeparator+'d2',ClassFileName,'file','y');

+PrintStringInfo('d0u82u82' +ArgSeparator+'u82',ClassFileName,'file','y');

+PrintStringInfo('d0u162u162' +ArgSeparator+'u162',ClassFileName,'file','y');

+PrintStringInfo('d0i82i82' +ArgSeparator+'i82',ClassFileName,'file','y');

+PrintStringInfo('d0i162i162' +ArgSeparator+'i162',ClassFileName,'file','y');

+

+

+

+PrintStringInfo('c0c0'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('c0c2'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('c2c0'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('c2c2'+ArgSeparator+'c2',ClassFileName,'file','y');

+

+PrintStringInfo('z0z0'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('z0z2'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('z2z0'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('z2z2'+ArgSeparator+'z2',ClassFileName,'file','y');

+

+PrintStringInfo('u80u80'+ArgSeparator+'u82',ClassFileName,'file','y');

+PrintStringInfo('u80u82'+ArgSeparator+'u82',ClassFileName,'file','y');

+PrintStringInfo('u82u80'+ArgSeparator+'u82',ClassFileName,'file','y');

+PrintStringInfo('u82u82'+ArgSeparator+'u82',ClassFileName,'file','y');

+PrintStringInfo('u160u160'+ArgSeparator+'u162',ClassFileName,'file','y');

+PrintStringInfo('u160u162'+ArgSeparator+'u162',ClassFileName,'file','y');

+PrintStringInfo('u162u160'+ArgSeparator+'u162',ClassFileName,'file','y');

+PrintStringInfo('u162u162'+ArgSeparator+'u162',ClassFileName,'file','y');

+PrintStringInfo('i80i80'+ArgSeparator+'i82',ClassFileName,'file','y');

+PrintStringInfo('i80i82'+ArgSeparator+'i82',ClassFileName,'file','y');

+PrintStringInfo('i82i80'+ArgSeparator+'i82',ClassFileName,'file','y');

+PrintStringInfo('i82i82'+ArgSeparator+'i82',ClassFileName,'file','y');

+PrintStringInfo('i160i160'+ArgSeparator+'i162',ClassFileName,'file','y');

+PrintStringInfo('i160i162'+ArgSeparator+'i162',ClassFileName,'file','y');

+PrintStringInfo('i162i160'+ArgSeparator+'i162',ClassFileName,'file','y');

+PrintStringInfo('i162i162'+ArgSeparator+'i162',ClassFileName,'file','y');

+

+PrintStringInfo('z0d0'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('z2d0'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('c0s0'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('c2s0'+ArgSeparator+'c2',ClassFileName,'file','y');

+

+PrintStringInfo('s0c0'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('s2c0'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('d0z0'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('d2z0'+ArgSeparator+'z2',ClassFileName,'file','y');

+

+PrintStringInfo('s2c2'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('c2s2'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('d2z2'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('z2d2'+ArgSeparator+'z2',ClassFileName,'file','y');

+

+PrintStringInfo('s0c2'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('c0s2'+ArgSeparator+'c2',ClassFileName,'file','y');

+PrintStringInfo('d0z2'+ArgSeparator+'z2',ClassFileName,'file','y');

+PrintStringInfo('z0d2'+ArgSeparator+'z2',ClassFileName,'file','y');

+

+// --- Annotation Function And Function List Function. ---

+FunctionName = 'cat'; // AS : Done  AS : Float_Done

+PrintStringInfo('      Adding Function: '+FunctionName+'.',GeneralReport,'file','y');

+INIT_GenAnnFLFunctions(FunctionName,SCI2CLibCAnnFunDir,ClassName,GeneralReport,ExtensionCAnnFun);

+INIT_GenAnnFLFunctions(FunctionName,SCI2CLibCFLFunDir,ClassName,GeneralReport,ExtensionCFuncListFun);

+

+// -------------------

 // --- Class Find. ---

 // -------------------

 ClassName = 'Find';

diff --git a/2.3-1/macros/findDeps/getAllInterfaces.sci b/2.3-1/macros/findDeps/getAllInterfaces.sci
index 194a9ab5..65ee1745 100644
--- a/2.3-1/macros/findDeps/getAllInterfaces.sci
+++ b/2.3-1/macros/findDeps/getAllInterfaces.sci
@@ -32,6 +32,7 @@ function allInterfaces = getAllInterfaces(OutFormat)
       "src/c/matrixOperations/interfaces/int_vmagn.h"
       "src/c/matrixOperations/interfaces/int_ones.h"
       "src/c/matrixOperations/interfaces/int_spec.h"
+      "src/c/matrixOperations/interfaces/int_cat.h"
       "src/c/matrixOperations/interfaces/int_zeros.h"
       "src/c/matrixOperations/interfaces/int_OpBackSlash.h"
       "src/c/matrixOperations/interfaces/int_OpApex.h"
diff --git a/2.3-1/macros/findDeps/getAllSources.sci b/2.3-1/macros/findDeps/getAllSources.sci
index c8d6d0b4..56a8fea0 100644
--- a/2.3-1/macros/findDeps/getAllSources.sci
+++ b/2.3-1/macros/findDeps/getAllSources.sci
@@ -89,6 +89,14 @@ function allSources = getAllSources(OutFormat)
       "src/c/matrixOperations/cat/zcats.c"
       "src/c/matrixOperations/cat/ccata.c"
       "src/c/matrixOperations/cat/ccats.c"
+      "src/c/matrixOperations/cat/u8cats.c"
+      "src/c/matrixOperations/cat/u8cata.c"
+      "src/c/matrixOperations/cat/u16cats.c"
+      "src/c/matrixOperations/cat/u16cata.c"
+      "src/c/matrixOperations/cat/i8cats.c"
+      "src/c/matrixOperations/cat/i8cata.c"
+      "src/c/matrixOperations/cat/i16cats.c"
+      "src/c/matrixOperations/cat/i16cata.c"
       "src/c/matrixOperations/eye/deyea.c"
       "src/c/matrixOperations/eye/seyea.c"
       "src/c/matrixOperations/eye/zeyea.c"
@@ -178,6 +186,10 @@ function allSources = getAllSources(OutFormat)
       "src/c/matrixOperations/multiplication/cmulma.c"
       "src/c/matrixOperations/multiplication/dmulma.c"
       "src/c/matrixOperations/multiplication/smulma.c"
+      "src/c/matrixOperations/multiplication/u8mulma.c"
+      "src/c/matrixOperations/multiplication/u16mulma.c"
+      "src/c/matrixOperations/multiplication/i8mulma.c"
+      "src/c/matrixOperations/multiplication/i16mulma.c"
       "src/c/matrixOperations/division/cldivma.c"
       "src/c/matrixOperations/division/zldivma.c"
       "src/c/matrixOperations/division/sldivma.c"
@@ -206,6 +218,14 @@ function allSources = getAllSources(OutFormat)
       "src/c/matrixOperations/magnitude/smagns.c"
       "src/c/matrixOperations/magnitude/zmagna.c"
       "src/c/matrixOperations/magnitude/zmagns.c"
+      "src/c/matrixOperations/magnitude/u8magna.c"
+      "src/c/matrixOperations/magnitude/u8magns.c"
+      "src/c/matrixOperations/magnitude/u16magna.c"
+      "src/c/matrixOperations/magnitude/u16magns.c"
+      "src/c/matrixOperations/magnitude/i8magna.c"
+      "src/c/matrixOperations/magnitude/i8magns.c"
+      "src/c/matrixOperations/magnitude/i16magna.c"
+      "src/c/matrixOperations/magnitude/i16magns.c"
       "src/c/matrixOperations/hilb/shilba.c"
       "src/c/matrixOperations/hilb/dhilba.c"
       "src/c/matrixOperations/squaredMagnitude/ssquMagna.c"
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;
+      
+  }
+
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/i16columnsuma.c b/2.3-1/src/c/statisticsFunctions/sum/i16columnsuma.c
new file mode 100644
index 00000000..c097be8b
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/i16columnsuma.c
@@ -0,0 +1,33 @@
+/*
+ *  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 "sum.h"
+
+void i16columnsuma(int16 *in, int lines, int columns, int16 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < lines; ++i)
+    {
+      out[i] = (int16)in[i];
+    }
+  /*
+  ** Then accumulate in each row.
+  */
+  for (i = lines ; i < lines * columns ; ++i)
+    {
+      out[i % lines] = (int16)i16adds(out[i % lines] , in[i]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/i16rowsuma.c b/2.3-1/src/c/statisticsFunctions/sum/i16rowsuma.c
new file mode 100644
index 00000000..2d9c3122
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/i16rowsuma.c
@@ -0,0 +1,34 @@
+/*
+ *  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 "sum.h"
+
+void i16rowsuma(int16 *in, int lines, int columns, int16 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < columns; ++i)
+    {
+      out[i] = (int16)in[i * lines];
+    }
+  /*
+  ** Then accumulate in each column.
+  */
+  for (i = 1 ; i <= (lines - 1) * columns ; ++i)
+    {
+      out[(i - 1) % columns] = (int16)i16adds( out[(i - 1) % columns] ,
+				      in[((i - 1) % columns) * lines + 1 + (i - 1) / columns]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/i16suma.c b/2.3-1/src/c/statisticsFunctions/sum/i16suma.c
new file mode 100644
index 00000000..c1a392ac
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/i16suma.c
@@ -0,0 +1,25 @@
+/*
+ *  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 "sum.h"
+
+int16 i16suma(int16 *in, int size) {
+ //floatComplex accumulate = FloatComplex(0.0f, 0.0f);
+  int i = 0;
+  int16 accumulate = 0;
+
+  for (i = 0; i < size; ++i)
+    {
+      accumulate = i16adds(accumulate, in[i]);
+    }
+  return accumulate;
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/i8columnsuma.c b/2.3-1/src/c/statisticsFunctions/sum/i8columnsuma.c
new file mode 100644
index 00000000..6550a18a
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/i8columnsuma.c
@@ -0,0 +1,33 @@
+/*
+ *  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 "sum.h"
+
+void i8columnsuma(int8 *in, int lines, int columns, int8 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < lines; ++i)
+    {
+      out[i] = (int8)in[i];
+    }
+  /*
+  ** Then accumulate in each row.
+  */
+  for (i = lines ; i < lines * columns ; ++i)
+    {
+      out[i % lines] = (int8)i8adds(out[i % lines] , in[i]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/i8rowsuma.c b/2.3-1/src/c/statisticsFunctions/sum/i8rowsuma.c
new file mode 100644
index 00000000..c975bae3
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/i8rowsuma.c
@@ -0,0 +1,34 @@
+/*
+ *  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 "sum.h"
+
+void i8rowsuma(int8 *in, int lines, int columns, int8 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < columns; ++i)
+    {
+      out[i] = (int8)in[i * lines];
+    }
+  /*
+  ** Then accumulate in each column.
+  */
+  for (i = 1 ; i <= (lines - 1) * columns ; ++i)
+    {
+      out[(i - 1) % columns] = (int8)i8adds( out[(i - 1) % columns] ,
+				      in[((i - 1) % columns) * lines + 1 + (i - 1) / columns]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/i8suma.c b/2.3-1/src/c/statisticsFunctions/sum/i8suma.c
new file mode 100644
index 00000000..e413ede3
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/i8suma.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
+ *
+ */
+
+#include "sum.h"
+
+int8 i8suma(int8 *in, int size) {
+ //floatComplex accumulate = FloatComplex(0.0f, 0.0f);
+  int8 accumulate = 0;
+  
+  int i = 0;
+
+  for (i = 0; i < size; ++i)
+    {
+      accumulate = i8adds(accumulate, in[i]);
+    }
+  return accumulate;
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/u16columnsuma.c b/2.3-1/src/c/statisticsFunctions/sum/u16columnsuma.c
new file mode 100644
index 00000000..895fe04f
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/u16columnsuma.c
@@ -0,0 +1,33 @@
+/*
+ *  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 "sum.h"
+
+void u16columnsuma(uint16 *in, int lines, int columns, uint16 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < lines; ++i)
+    {
+      out[i] = (uint16)in[i];
+    }
+  /*
+  ** Then accumulate in each row.
+  */
+  for (i = lines ; i < lines * columns ; ++i)
+    {
+      out[i % lines] = (uint16)u16adds(out[i % lines] , in[i]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/u16rowsuma.c b/2.3-1/src/c/statisticsFunctions/sum/u16rowsuma.c
new file mode 100644
index 00000000..3adb206e
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/u16rowsuma.c
@@ -0,0 +1,34 @@
+/*
+ *  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 "sum.h"
+
+void u16rowsuma(uint16 *in, int lines, int columns, uint16 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < columns; ++i)
+    {
+      out[i] = (uint16)in[i * lines];
+    }
+  /*
+  ** Then accumulate in each column.
+  */
+  for (i = 1 ; i <= (lines - 1) * columns ; ++i)
+    {
+      out[(i - 1) % columns] = (uint16)u16adds( out[(i - 1) % columns] ,
+				     in[((i - 1) % columns) * lines + 1 + (i - 1) / columns]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/u16suma.c b/2.3-1/src/c/statisticsFunctions/sum/u16suma.c
new file mode 100644
index 00000000..0130f7af
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/u16suma.c
@@ -0,0 +1,25 @@
+/*
+ *  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 "sum.h"
+
+uint16 u16suma(uint16 *in, int size) {
+  //floatComplex accumulate = FloatComplex(0.0f, 0.0f);
+  int i = 0;
+  uint16 accumulate = 0;
+
+  for (i = 0; i < size; ++i)
+    {
+      accumulate = u16adds(accumulate, in[i]);
+    }
+  return accumulate;
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/u8columnsuma.c b/2.3-1/src/c/statisticsFunctions/sum/u8columnsuma.c
new file mode 100644
index 00000000..5484b4a4
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/u8columnsuma.c
@@ -0,0 +1,33 @@
+/*
+ *  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 "sum.h"
+
+void u8columnsuma(uint8 *in, int lines, int columns, uint8 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < lines; ++i)
+    {
+      out[i] = (uint8)in[i];
+    }
+  /*
+  ** Then accumulate in each row.
+  */
+  for (i = lines ; i < lines * columns ; ++i)
+    {
+      out[i % lines] = (uint8)u8adds(out[i % lines] , in[i]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/u8rowsuma.c b/2.3-1/src/c/statisticsFunctions/sum/u8rowsuma.c
new file mode 100644
index 00000000..938af400
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/u8rowsuma.c
@@ -0,0 +1,34 @@
+/*
+ *  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 "sum.h"
+
+void u8rowsuma(uint8 *in, int lines, int columns, uint8 * out) {
+  int i = 0;
+
+  /*
+  ** First assign first row, just in case
+  ** out contains non-zero's elements.
+  */
+  for (i = 0 ; i < columns; ++i)
+    {
+      out[i] = (uint8)in[i * lines];
+    }
+  /*
+  ** Then accumulate in each column.
+  */
+  for (i = 1 ; i <= (lines - 1) * columns ; ++i)
+    {
+      out[(i - 1) % columns] = (uint8)u8adds( out[(i - 1) % columns] ,
+				      in[((i - 1) % columns) * lines + 1 + (i - 1) / columns]);
+    }
+}
diff --git a/2.3-1/src/c/statisticsFunctions/sum/u8suma.c b/2.3-1/src/c/statisticsFunctions/sum/u8suma.c
new file mode 100644
index 00000000..cb80b336
--- /dev/null
+++ b/2.3-1/src/c/statisticsFunctions/sum/u8suma.c
@@ -0,0 +1,25 @@
+/*
+ *  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 "sum.h"
+
+uint8 u8suma(uint8 *in, int size) {
+   //floatComplex accumulate = FloatComplex(0.0f, 0.0f);
+   int i = 0;
+   uint8 accumulate = 0;
+
+  for (i = 0; i < size; ++i)
+    {
+      accumulate = u8adds(accumulate, in[i]);
+    }
+  return accumulate;
+}