From d17b33131c14864bd1eae275f49a3f148e21cf29 Mon Sep 17 00:00:00 2001
From: Leo Chan <leochanj@live.unc.edu>
Date: Thu, 22 Oct 2020 01:53:21 -0400
Subject: Squashed commit of the sb-vbs branch.

Includes the SD-VBS benchmarks modified to:
- Use libextra to loop as realtime jobs
- Preallocate memory before starting their main computation
- Accept input via stdin instead of via argc

Does not include the SD-VBS matlab code.

Fixes libextra execution in LITMUS^RT.
---
 SD-VBS/benchmarks/svm/src/c/cal_learned_func.c     |  42 +++++
 SD-VBS/benchmarks/svm/src/c/examineExample.c       |  67 ++++++++
 SD-VBS/benchmarks/svm/src/c/getAlphaFromTrainSet.c |  98 +++++++++++
 SD-VBS/benchmarks/svm/src/c/polynomial.c           |  42 +++++
 SD-VBS/benchmarks/svm/src/c/script_svm.c           | 171 +++++++++++++++++++
 SD-VBS/benchmarks/svm/src/c/svm.h                  |  38 +++++
 SD-VBS/benchmarks/svm/src/c/takeStep.c             | 188 +++++++++++++++++++++
 SD-VBS/benchmarks/svm/src/c/usps_read_partial.c    |  85 ++++++++++
 8 files changed, 731 insertions(+)
 create mode 100644 SD-VBS/benchmarks/svm/src/c/cal_learned_func.c
 create mode 100644 SD-VBS/benchmarks/svm/src/c/examineExample.c
 create mode 100644 SD-VBS/benchmarks/svm/src/c/getAlphaFromTrainSet.c
 create mode 100644 SD-VBS/benchmarks/svm/src/c/polynomial.c
 create mode 100644 SD-VBS/benchmarks/svm/src/c/script_svm.c
 create mode 100644 SD-VBS/benchmarks/svm/src/c/svm.h
 create mode 100644 SD-VBS/benchmarks/svm/src/c/takeStep.c
 create mode 100644 SD-VBS/benchmarks/svm/src/c/usps_read_partial.c

(limited to 'SD-VBS/benchmarks/svm/src')

diff --git a/SD-VBS/benchmarks/svm/src/c/cal_learned_func.c b/SD-VBS/benchmarks/svm/src/c/cal_learned_func.c
new file mode 100644
index 0000000..79fdd68
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/cal_learned_func.c
@@ -0,0 +1,42 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include "svm.h"
+
+float cal_learned_func(int k, F2D* a, float* b, int N, F2D* Y, F2D* X, int dim)
+{
+    float s, ret;
+    int i, j, m, n;
+    F2D *temp, *temp1;
+
+    s=0;
+    for(i=0; i<N; i++)
+    {
+        if( subsref(a,i,0) > 0)
+        {
+            temp = fMallocHandle(1, X->width);
+            temp1 = fMallocHandle(1, X->width);
+
+            for(m=0; m<X->width; m++)
+            {
+                asubsref(temp,m) = subsref(X,i,m);
+                asubsref(temp1,m) = subsref(X,k,m);
+            }
+
+            s += asubsref(a,i) * asubsref(Y,i) * polynomial(3, temp, temp1, dim);
+
+            free(temp);
+            free(temp1);
+        }
+    }
+
+    s = s- arrayref(b,0);
+    ret = s;
+
+    return ret;
+}
+
+
+
+
diff --git a/SD-VBS/benchmarks/svm/src/c/examineExample.c b/SD-VBS/benchmarks/svm/src/c/examineExample.c
new file mode 100644
index 0000000..5335f35
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/examineExample.c
@@ -0,0 +1,67 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include "svm.h"
+
+int examineExample(int i, F2D* a, float* b, float C, F2D* e, F2D* X, F2D* Y, float tolerance, int N, float eps, int dim)
+{
+    int  ret, j, k, m, n;
+    float E, r1, randVal;
+    float maxDiff, temp;
+
+    if( ( asubsref(a,i) > 0) && ( asubsref(a,i) <C) )
+        E = asubsref(e,i);
+    else
+        E = cal_learned_func(i, a, b, N, Y, X, dim) - asubsref(Y,i);
+
+    r1 = subsref(Y,i,0) * E;
+    if( ((r1 < (-1*tolerance)) && ( asubsref(a,i) < C)) || ((r1 >tolerance) && ( asubsref(a,i) > 0)) )
+    {
+        maxDiff = 0;
+        j = i;
+
+        for(k=0; k<N; k++)
+        {
+            if( ( asubsref(a,k) > 0) && ( asubsref(a,k) < C) )
+            {
+                temp = fabsf( E - asubsref(e,k));
+                if (temp > maxDiff)
+                    j = k;
+            }
+        }
+
+        if ( i!=j)
+        {
+            ret = takeStep(i, j, a, C, e, Y, X, eps, b, N, dim);
+            if(ret == 1)
+                return ret;
+        }
+
+        randVal = 1.0;
+        for( k= (randVal*(N-2)); k<N; k++)
+        {
+            if( ( asubsref(a,k) > 0) && ( asubsref(a,k) <C) )
+            {
+                ret = takeStep(i, k, a, C, e, Y, X, eps, b, N, dim);
+                if (ret == 1)
+                    return ret;
+            }
+        }
+
+        for(k=0; k<N; k++)
+        {
+            ret = takeStep(i, k, a, C, e, Y, X, eps, b, N, dim);
+            if(ret == 1)
+                return ret;
+        }
+    }
+
+    
+    ret = 0;
+    return ret;
+}
+
+
+
+
diff --git a/SD-VBS/benchmarks/svm/src/c/getAlphaFromTrainSet.c b/SD-VBS/benchmarks/svm/src/c/getAlphaFromTrainSet.c
new file mode 100644
index 0000000..681f2c6
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/getAlphaFromTrainSet.c
@@ -0,0 +1,98 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include "svm.h"
+
+alphaRet* getAlphaFromTrainSet(int N, F2D* trn1, F2D* trn2, int iterations)
+{
+    float tolerance, C, eps, *b;
+    F2D *a_result, *b_result;
+    int NumChanged, r, ExamineAll, cnt, d, dim, ret, iter, i;
+    F2D *X, *Y;
+    F2D *a, *e;
+
+    b = malloc(sizeof(float));
+    alphaRet* alpha;
+    alpha = (alphaRet*)malloc(sizeof(alphaRet));
+    tolerance = 0.001;
+    C = 0.05;
+    d = -1;
+    dim = 256;
+    eps = 0.001;
+    a_result = fSetArray(iterations, N, 0);
+    b_result = fSetArray(iterations, 1, 0);
+    ret = 0;
+    
+    X = usps_read_partial( trn1, trn2, 0, 1, (N/iterations), iterations);
+    
+    for(iter=0; iter<iterations; iter++)
+    {
+        Y = usps_read_partial( trn1, trn2, iter, 0, N/iterations, iterations);
+        
+        a = fSetArray(N, 1, 0);
+        arrayref(b,0) = 0;                  /** check if ptr **/
+        e = fSetArray(N, 1, 0);
+        ExamineAll = 1;
+        cnt = 0;
+        NumChanged = 0;
+
+        while(NumChanged>0 || ExamineAll == 1)
+        {
+            cnt = cnt + 1;
+            NumChanged = 0;
+            if(ExamineAll == 1)
+            {
+                for(i=0; i<N; i++)
+                {
+                    ret = examineExample(i, a, b, C, e, X, Y, tolerance, N, eps, dim);
+                    NumChanged = NumChanged + ret;
+                }
+            }
+            else
+            {
+                for(i=0; i<N; i++)
+                {
+                    if( asubsref(a,i) > 0 && asubsref(a,i) <C )
+                    {
+                        ret = examineExample(i, a, b, C, e, X, Y, tolerance, N, eps, dim);
+                        NumChanged = NumChanged + ret;
+                    }
+                }
+            }
+            if(ExamineAll == 1)
+                ExamineAll = 0;
+            else if(NumChanged == 0)
+                ExamineAll = 1;
+        }
+
+        for(r=0; r<N; r++)
+            subsref(a_result,iter,r) = asubsref(a,r);   /** a_result has size iteration,N .. Check **/
+        asubsref(b_result,iter) = arrayref(b,0);
+
+        fFreeHandle(Y);
+        fFreeHandle(e);
+        fFreeHandle(a);
+    }
+  
+    alpha->C = C;
+    alpha->d = d;
+    alpha->dim = dim;
+    alpha->eps = eps;
+    alpha->a_result = a_result;
+    alpha->b_result = b_result;
+    alpha->a = a;
+    alpha->b = arrayref(b,0);
+    alpha->X = X;
+    alpha->tolerance = tolerance;
+    alpha->ret;
+    
+    free(b);
+   
+    return alpha; 
+
+}
+
+
+
+
diff --git a/SD-VBS/benchmarks/svm/src/c/polynomial.c b/SD-VBS/benchmarks/svm/src/c/polynomial.c
new file mode 100644
index 0000000..cce9190
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/polynomial.c
@@ -0,0 +1,42 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include "svm.h"
+
+float polynomial(int d, F2D* a, F2D* b, int dim)
+{
+    float ret;
+    F2D *bt, *bt1;
+    int i,j,r,c;
+
+    r = b->height;
+    c = b->width;
+
+    bt = fMallocHandle(c, r);
+
+    for(i=0; i<r; i++)
+    {
+        for(j=0; j<c; j++)
+        {
+            subsref(bt,j,i) = subsref(b,i,j);
+        }
+    }
+
+    bt1 = fMtimes(a, bt);
+    fFreeHandle(bt);
+    
+    if(bt1->height == 1 && bt1->width ==1)
+        ret = pow(asubsref(bt1,0),d)/dim;
+    else
+    {
+        fFreeHandle(bt1);
+        return -1;
+    }
+
+    fFreeHandle(bt1);
+    return ret;
+}
+
+
+
diff --git a/SD-VBS/benchmarks/svm/src/c/script_svm.c b/SD-VBS/benchmarks/svm/src/c/script_svm.c
new file mode 100644
index 0000000..62a264d
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/script_svm.c
@@ -0,0 +1,171 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "svm.h"
+#include <malloc.h>
+#include "extra.h"
+#define SVM_MEM 1<<24
+int main(int argc, char* argv[])
+{
+    SET_UP
+    mallopt(M_TOP_PAD, SVM_MEM);
+    mallopt(M_MMAP_MAX, 0);
+    int iter, N, Ntst, i, j, k, n;
+    F2D* trn1, *tst1, *trn2, *tst2, *Yoffset;
+    alphaRet* alpha;
+    F2D *a_result, *result;
+    F2D *s;
+    F2D *b_result;
+    F2D *Xtst, *Ytst;
+    char im1[256];
+    int dim = 256;
+
+    N = 100;
+    Ntst = 100;
+    iter = 10;
+
+    #ifdef test
+    N = 4;
+    Ntst = 4;
+    iter = 2;
+    #endif
+    
+    #ifdef sim_fast
+    N = 20;
+    Ntst = 20;
+    iter = 2;
+    #endif
+
+    #ifdef sim
+    N = 16;
+    Ntst = 16;
+    iter = 8;
+    #endif
+    
+    #ifdef sqcif
+    N = 60;
+    Ntst = 60;
+    iter = 6;
+    #endif
+    
+    #ifdef qcif
+    N = 72;
+    Ntst = 72;
+    iter = 8;
+    #endif
+    
+    #ifdef vga
+    N = 450;
+    Ntst = 450;
+    iter = 15;
+    #endif
+    
+    #ifdef wuxga
+    N = 1000;
+    Ntst = 1000;
+    iter = 20;
+    #endif
+
+
+    printf("trn file 1: ");
+    scanf("%s", im1);
+    trn1 = readFile(im1);   
+
+    printf("trn file 2: ");
+    scanf("%s", im1);
+    trn2 = readFile(im1);   
+
+    printf("tst file 1: ");
+    scanf("%s", im1);
+    tst1 = readFile(im1);   
+
+    printf("tst file 2: ");
+    scanf("%s", im1);
+    tst2 = readFile(im1);       
+
+    printf("start.\n");
+    for_each_job{
+        alpha = getAlphaFromTrainSet(N, trn1, trn2, iter);
+        a_result = alpha->a_result;
+        b_result = alpha->b_result;
+        Yoffset = fSetArray(iter, N, 0);
+    
+        Xtst = usps_read_partial(tst1, tst2, -1, 1, Ntst/iter, iter);
+        Ytst = usps_read_partial(tst1, tst2, -1, 0, Ntst/iter, iter);
+    
+        for(i=0; i<iter; i++)
+        {
+            F2D *temp;
+            temp = usps_read_partial(trn1, trn2, i, 0, N/iter, iter);
+            for(j=0; j<N; j++)
+                subsref(Yoffset,i,j) = asubsref(temp,j);
+            fFreeHandle(temp);
+        }
+    
+    
+        result = fSetArray(Ntst,1,0);
+        for( n=0; n<Ntst; n++)
+        {
+            float maxs=0;
+            s=fSetArray(iter,1,0);
+            for( i=0; i<iter; i++)
+            {
+                for (j=0; j<N; j++)
+                {
+                    if (subsref(a_result,i,j) > 0)
+                    {
+                        F2D *Xtemp, *XtstTemp, *X;
+                        X = alpha->X;
+                        Xtemp = fDeepCopyRange(X,j,1,0,X->width);
+                        XtstTemp = fDeepCopyRange(Xtst, n,1,0,Xtst->width);
+                        asubsref(s,i) = asubsref(s,i) + subsref(a_result,i,j) * subsref(Yoffset,i,j) * polynomial(3,Xtemp,XtstTemp, dim);
+                        fFreeHandle(Xtemp); 
+                        fFreeHandle(XtstTemp); 
+                    }
+                }
+                asubsref(s,i) = asubsref(s,i) - asubsref(b_result,i);
+                if( asubsref(s,i) > maxs)
+                    maxs = asubsref(s,i);
+            }
+            
+            fFreeHandle(s);
+            asubsref(result,n) = maxs;
+        }
+    }
+    printf("end..\n");
+#ifdef CHECK   
+    /** Self checking - use expected.txt from data directory  **/
+    {
+        int ret=0;
+        float tol = 0.5;
+#ifdef GENERATE_OUTPUT
+        fWriteMatrix(result, argv[1]);
+#endif
+        ret = fSelfCheck(result, "expected_C.txt", tol);
+        if (ret == -1)
+            printf("Error in SVM\n");
+    }
+    /** Self checking done **/
+#endif
+
+    fFreeHandle(trn1);
+    fFreeHandle(tst1);
+    fFreeHandle(trn2);
+    fFreeHandle(tst2);
+    fFreeHandle(Yoffset);
+    fFreeHandle(result);
+    fFreeHandle(alpha->a_result);
+    fFreeHandle(alpha->b_result);
+    fFreeHandle(alpha->X);
+    free(alpha);
+    fFreeHandle(Xtst);
+    fFreeHandle(Ytst);
+    WRITE_TO_FILE
+    return 0;
+}
+
+
+
diff --git a/SD-VBS/benchmarks/svm/src/c/svm.h b/SD-VBS/benchmarks/svm/src/c/svm.h
new file mode 100644
index 0000000..9675371
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/svm.h
@@ -0,0 +1,38 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#ifndef _SCRIPT_SVM_
+#define _SCRIPT_SVM_
+
+#include "sdvbs_common.h"
+
+typedef struct
+{
+    F2D* a;
+    float b;
+    float C;
+    int d;
+    int dim;
+    F2D* e;
+    float eps;
+    F2D* a_result;
+    F2D* b_result;
+    F2D* X;
+    F2D *Y;
+    float tolerance;
+    int ret;
+
+}alphaRet;
+
+alphaRet* getAlphaFromTrainSet(int N, F2D* trn1, F2D* trn2, int iterations);
+float polynomial(int d, F2D* a, F2D* b, int dim);
+float cal_learned_func(int k, F2D* a, float* b, int N, F2D* Y, F2D* X, int dim);
+int examineExample(int i, F2D* a, float* b, float C, F2D* e, F2D* X, F2D* Y, float tolerance, int N, float eps, int dim);
+int takeStep(int i, int j, F2D* a, float C, F2D* e, F2D* Y, F2D* X, float eps, float* b, int N, int dim);
+F2D* usps_read_partial(F2D* dcell1, F2D* dcell2, int idx, int opt, int dim, int iterations);
+int script_svm();
+
+#endif
+
+
diff --git a/SD-VBS/benchmarks/svm/src/c/takeStep.c b/SD-VBS/benchmarks/svm/src/c/takeStep.c
new file mode 100644
index 0000000..ae550c2
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/takeStep.c
@@ -0,0 +1,188 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include "svm.h"
+
+int takeStep(int i, int j, F2D* a, float C, F2D* e, F2D* Y, F2D* X, float eps, float* b, int N, int dim)
+{
+    int ret=1;
+    float s;
+    int m, n, k;
+    float Ei, Ej, gamma, L, H;
+    F2D *a_old;
+    float k11, k12, k22, eta;
+    F2D *temp, *temp1, *temp2;
+    float t, t1, t2;
+    float bnew, delta_b;
+    float c1, c2, Lobj, Hobj;
+    
+    if(i==j)
+        return 0;
+        
+    a_old = fDeepCopy(a);
+    
+    if( asubsref(a_old,i)>0 && asubsref(a_old,i)<C ) 
+        Ei = asubsref(e,i);
+    else
+        Ei = cal_learned_func(i, a, b, N, Y, X, dim) - asubsref(Y,i);
+
+    if( asubsref(a_old,j)>0 && asubsref(a_old,j)<C ) 
+        Ej = asubsref(e,j);
+    else
+        Ej = cal_learned_func(j, a, b, N, Y, X, dim) - asubsref(Y,j);
+
+    s = asubsref(Y,i) * asubsref(Y,j);
+
+    if( asubsref(Y,i) == asubsref(Y,j) )
+    {
+        gamma = asubsref(a_old,i) + asubsref(a_old,j);
+        if(gamma > C)
+        {
+            L = gamma - C;
+            H = C;
+        }
+        else
+        {
+            L = 0;
+            H = gamma;
+        }
+    }
+    else
+    {
+        gamma = asubsref(a_old,i) - asubsref(a_old,j);
+        if(gamma > 0)
+        {
+            L = 0;
+            H = C - gamma;
+        }
+        else
+        {
+            L = -gamma;
+            H = C;
+        }
+    }
+    
+
+    if(L==H)
+    {
+        fFreeHandle(a_old);
+        return 0;
+    }
+           
+    temp = fMallocHandle(1, X->width);
+    temp1 = fMallocHandle(1, X->width);
+
+    for(m=0; m<X->width; m++)
+    {
+        asubsref(temp,m) = subsref(X,i,m);
+        asubsref(temp1,m) = subsref(X,j,m);
+    }
+
+    k11 = polynomial(3, temp, temp, dim);
+    k12 = polynomial(3, temp, temp1, dim);
+    k22 = polynomial(3, temp1, temp1, dim);
+    eta = 2 * k12 - k11 - k22;
+
+    fFreeHandle(temp1);
+    fFreeHandle(temp);
+
+    if(eta<0)
+    {
+        asubsref(a,j) = asubsref(a_old,j) + asubsref(Y,j) * (Ej-Ei)/eta;
+        if( asubsref(a,j) < L)
+            asubsref(a,j) = L;
+        else if( asubsref(a,j) > H )
+            asubsref(a,j) = H;
+    }
+    else
+    {
+        c1 = eta/2;
+        c2 = asubsref(Y,j) * (Ei-Ej) - eta * asubsref(a_old,j);
+        Lobj = c1 * L * L + c2 * L;
+        Hobj = c1 * H * H + c2 * H;
+
+        if (Lobj > (Hobj+eps))
+            asubsref(a,j) = L;
+        else if (Lobj < (Hobj-eps))
+            asubsref(a,j) = H;
+        else
+            asubsref(a,j) = asubsref(a_old,j);
+    }
+    
+    if( fabsf( asubsref(a,j)- asubsref(a_old,j) ) < (eps* (asubsref(a,j) + asubsref(a_old,j) +eps)) )
+    {
+        fFreeHandle(a_old);
+        return 0;
+    }
+
+    asubsref(a,i) = asubsref(a_old,i) - s * ( asubsref(a,j) - asubsref(a_old,j) );
+
+    if( asubsref(a,i) < 0)
+    {
+        asubsref(a,j) = asubsref(a,j) + s * asubsref(a,i);
+        asubsref(a,i) = 0;
+    }
+    else if (asubsref(a,i) > C)
+    {
+        t = asubsref(a,i) - C;
+        asubsref(a,j) = asubsref(a,j) + s * t;
+        asubsref(a,i) = C;
+    }
+
+    /** Update threshold to react change in Lagrange multipliers **/
+
+    if( asubsref(a,i) > 0 && asubsref(a,i) < C )
+        bnew = arrayref(b,0) + Ei + asubsref(Y,i) * (asubsref(a,i) - asubsref(a_old,i)) * k11 + asubsref(Y,j) * (asubsref(a,j) - asubsref(a_old,j)) * k12;
+    else
+    {
+        if( asubsref(a,j) > 0 && asubsref(a,j) < C )
+            bnew = arrayref(b,0) + Ej + asubsref(Y,i) * (asubsref(a,i) - asubsref(a_old,i)) * k12 + asubsref(Y,j) * (asubsref(a,j) - asubsref(a_old,j)) * k22;
+        else
+        {
+            float b1, b2;
+            b1 = arrayref(b,0) + Ei + asubsref(Y,i) * (asubsref(a,i) - asubsref(a_old,i)) * k11 + asubsref(Y,j) * (asubsref(a,j) - asubsref(a_old,j)) * k12;
+            b2 = arrayref(b,0) + Ej + asubsref(Y,i) * (asubsref(a,i) - asubsref(a_old,i)) * k12 + asubsref(Y,j) * (asubsref(a,j) - asubsref(a_old,j)) * k22;
+            bnew = (b1 + b2) / 2;
+        }
+    }
+    delta_b = bnew - arrayref(b,0);
+    arrayref(b,0) = bnew;
+
+    /** Update error cache using new Lagrange multipliers 24ai **/
+
+    t1 = asubsref(Y,i) * (asubsref(a,i)-asubsref(a_old,i));
+    t2 = asubsref(Y,j) * (asubsref(a,j)-asubsref(a_old,j));
+
+    temp = fMallocHandle(1, X->width);
+    temp1 = fMallocHandle(1, X->width);
+    temp2 = fMallocHandle(1, X->width);
+
+    for (k=0; k<N; k++)
+    {
+        if (0 < asubsref(a_old,i) && asubsref(a_old,i) < C )
+        {
+
+            for(m=0; m<X->width; m++)
+            {
+                asubsref(temp,m) = subsref(X,i,m);
+                asubsref(temp1,m) = subsref(X,k,m);
+                asubsref(temp2,m) = subsref(X,j,m);
+            }
+
+            asubsref(e,k) = asubsref(e,k)+t1 * polynomial(3, temp, temp1, dim) + t2 * polynomial(3, temp2, temp1, dim) - delta_b;
+            asubsref(e,i) = 0;
+            asubsref(e,j) = 0;
+        }
+    }
+    
+    fFreeHandle(a_old);
+    fFreeHandle(temp);
+    fFreeHandle(temp1);
+    fFreeHandle(temp2);
+    ret = 1;
+    return ret;
+}
+
+
+
diff --git a/SD-VBS/benchmarks/svm/src/c/usps_read_partial.c b/SD-VBS/benchmarks/svm/src/c/usps_read_partial.c
new file mode 100644
index 0000000..9cc9df0
--- /dev/null
+++ b/SD-VBS/benchmarks/svm/src/c/usps_read_partial.c
@@ -0,0 +1,85 @@
+/********************************
+Author: Sravanthi Kota Venkata
+********************************/
+
+#include "svm.h"
+
+F2D* usps_read_partial(F2D* dcell1, F2D* dcell2, int idx, int opt, int dim, int iterations)
+{
+    F2D *ret, *X, *Y;
+    F2D *ADD;
+    int i, j, k, m, n;
+
+    F2D *temp, *temp1;
+
+    if(opt == 1)
+    {
+        for(i=0; i<iterations; i++)
+        {
+            if(i==0)
+            {
+                X = fMallocHandle(dim, dcell1->width);
+                for(m=0; m<dim; m++)
+                {
+                    for(n=0; n<dcell1->width; n++)
+                    {
+                        subsref(X,m,n) = subsref(dcell1,m,n);
+                    }
+                }
+            }
+            else
+            {
+                temp = fDeepCopy(X);
+                fFreeHandle(X);
+                temp1 = fMallocHandle(dim, dcell2->width);
+
+                for(m=0; m<dim; m++)
+                {
+                    for(n=0; n<dcell2->width; n++)
+                    {
+                        subsref(temp1,m,n) = subsref(dcell2,m,n);
+                    }
+                }
+                X = ffVertcat(temp, temp1);
+                fFreeHandle(temp);
+                fFreeHandle(temp1);
+            }
+        }
+        ret = fDeepCopy(X);
+        fFreeHandle(X);
+    }
+    else
+    {
+        for(i=0; i<iterations; i++)
+        {
+            if(idx == -1)
+                ADD = fSetArray(dim, 1, i+1);
+            else
+            {
+                if( i!= idx)
+                    ADD = fSetArray(dim, 1, -1);
+                else
+                    ADD = fSetArray(dim, 1, 1);
+            }
+            if(i==0)
+            {
+                Y = fDeepCopy(ADD);
+            }
+            else
+            {
+                F2D* t = fDeepCopy(Y);
+                fFreeHandle(Y);
+                Y = ffVertcat(t, ADD);
+                fFreeHandle(t);
+            }
+            fFreeHandle(ADD);
+        }
+        ret = fDeepCopy(Y);
+        fFreeHandle(Y);
+    }
+    
+    return ret;
+}
+
+
+
-- 
cgit v1.2.2