libsvmread.c

Go to the documentation of this file.

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <ctype.h>
#include <errno.h>

#include "mex.h"

#ifdef MX_API_VER
#if MX_API_VER < 0x07030000
typedef int mwIndex;
#endif 
#endif 
#ifndef max
#define max(x,y) (((x)>(y))?(x):(y))
#endif
#ifndef min
#define min(x,y) (((x)<(y))?(x):(y))
#endif

void exit_with_help()
{
        mexPrintf(
        "Usage: [label_vector, instance_matrix] = libsvmread('filename');\n"
        );
}

static void fake_answer(mxArray *plhs[])
{
        plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL);
        plhs[1] = mxCreateDoubleMatrix(0, 0, mxREAL);
}

static char *line;
static int max_line_len;

static char* readline(FILE *input)
{
        int len;
        
        if(fgets(line,max_line_len,input) == NULL)
                return NULL;

        while(strrchr(line,'\n') == NULL)
        {
                max_line_len *= 2;
                line = (char *) realloc(line, max_line_len);
                len = (int) strlen(line);
                if(fgets(line+len,max_line_len-len,input) == NULL)
                        break;
        }
        return line;
}

// read in a problem (in libsvm format)
void read_problem(const char *filename, mxArray *plhs[])
{
        int max_index, min_index, inst_max_index, i;
        long elements, k;
        FILE *fp = fopen(filename,"r");
        int l = 0;
        char *endptr;
        mwIndex *ir, *jc;
        double *labels, *samples;
        
        if(fp == NULL)
        {
                mexPrintf("can't open input file %s\n",filename);
                fake_answer(plhs);
                return;
        }

        max_line_len = 1024;
        line = (char *) malloc(max_line_len*sizeof(char));

        max_index = 0;
        min_index = 1; // our index starts from 1
        elements = 0;
        while(readline(fp) != NULL)
        {
                char *idx, *val;
                // features
                int index = 0;

                inst_max_index = -1; // strtol gives 0 if wrong format, and precomputed kernel has <index> start from 0
                strtok(line," \t"); // label
                while (1)
                {
                        idx = strtok(NULL,":"); // index:value
                        val = strtok(NULL," \t");
                        if(val == NULL)
                                break;

                        errno = 0;
                        index = (int) strtol(idx,&endptr,10);
                        if(endptr == idx || errno != 0 || *endptr != '\0' || index <= inst_max_index)
                        {
                                mexPrintf("Wrong input format at line %d\n",l+1);
                                fake_answer(plhs);
                                return;
                        }
                        else
                                inst_max_index = index;

                        min_index = min(min_index, index);
                        elements++;
                }
                max_index = max(max_index, inst_max_index);
                l++;
        }
        rewind(fp);

        // y
        plhs[0] = mxCreateDoubleMatrix(l, 1, mxREAL);
        // x^T
        if (min_index <= 0)
                plhs[1] = mxCreateSparse(max_index-min_index+1, l, elements, mxREAL);
        else
                plhs[1] = mxCreateSparse(max_index, l, elements, mxREAL);

        labels = mxGetPr(plhs[0]);
        samples = mxGetPr(plhs[1]);
        ir = mxGetIr(plhs[1]);
        jc = mxGetJc(plhs[1]);

        k=0;
        for(i=0;i<l;i++)
        {
                char *idx, *val, *label;
                jc[i] = k;

                readline(fp);

                label = strtok(line," \t\n");
                if(label == NULL)
                {
                        mexPrintf("Empty line at line %d\n",i+1);
                        fake_answer(plhs);
                        return;
                }
                labels[i] = strtod(label,&endptr);
                if(endptr == label || *endptr != '\0')
                {
                        mexPrintf("Wrong input format at line %d\n",i+1);
                        fake_answer(plhs);
                        return;
                }

                // features
                while(1)
                {
                        idx = strtok(NULL,":");
                        val = strtok(NULL," \t");
                        if(val == NULL)
                                break;

                        ir[k] = (mwIndex) (strtol(idx,&endptr,10) - min_index); // precomputed kernel has <index> start from 0

                        errno = 0;
                        samples[k] = strtod(val,&endptr);
                        if (endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
                        {
                                mexPrintf("Wrong input format at line %d\n",i+1);
                                fake_answer(plhs);
                                return;
                        }
                        ++k;
                }
        }
        jc[l] = k;

        fclose(fp);
        free(line);

        {
                mxArray *rhs[1], *lhs[1];
                rhs[0] = plhs[1];
                if(mexCallMATLAB(1, lhs, 1, rhs, "transpose"))
                {
                        mexPrintf("Error: cannot transpose problem\n");
                        fake_answer(plhs);
                        return;
                }
                plhs[1] = lhs[0];
        }
}

void mexFunction( int nlhs, mxArray *plhs[],
                int nrhs, const mxArray *prhs[] )
{
        if(nrhs == 1)
        {
                char filename[256];

                mxGetString(prhs[0], filename, mxGetN(prhs[0]) + 1);

                if(filename == NULL)
                {
                        mexPrintf("Error: filename is NULL\n");
                        return;
                }

                read_problem(filename, plhs);
        }
        else
        {
                exit_with_help();
                fake_answer(plhs);
                return;
        }
}