tinysvm_wrap.c

机器学习工具：非常流行的一种分类器

    if (! SvOK((SV*) ST(1))) {
        arg1 = 0; 
    }
    else {
        arg1 = (char *) SvPV(ST(1),PL_na); 
    }
    if (items > 2) {
        if (! SvOK((SV*) ST(2))) {
            arg2 = 0; 
        }
        else {
            arg2 = (char *) SvPV(ST(2),PL_na); 
        }
    }
    if (items > 3) {
        arg3 = (int )SvIV(ST(3));
    }
    result = (int )arg0->write((char const *)arg1,(char const *)arg2,arg3);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_clear) {
    Model *arg0 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_clear(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_clear. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (int )arg0->clear();
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_classify) {
    Model *arg0 ;
    char *arg1 ;
    int argvi = 0;
    double result ;
    dXSARGS;
    
    if ((items < 2) || (items > 2)) 
    croak("Usage: Model_classify(self,char const *);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_classify. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    if (! SvOK((SV*) ST(1))) {
        arg1 = 0; 
    }
    else {
        arg1 = (char *) SvPV(ST(1),PL_na); 
    }
    result = (double )arg0->classify((char const *)arg1);
    ST(argvi) = sv_newmortal();
    sv_setnv(ST(argvi++), (double) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_estimateMargin) {
    Model *arg0 ;
    int argvi = 0;
    double result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_estimateMargin(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_estimateMargin. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (double )arg0->estimateMargin();
    ST(argvi) = sv_newmortal();
    sv_setnv(ST(argvi++), (double) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_estimateSphere) {
    Model *arg0 ;
    int argvi = 0;
    double result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_estimateSphere(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_estimateSphere. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (double )arg0->estimateSphere();
    ST(argvi) = sv_newmortal();
    sv_setnv(ST(argvi++), (double) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_estimateVC) {
    Model *arg0 ;
    int argvi = 0;
    double result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_estimateVC(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_estimateVC. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (double )arg0->estimateVC();
    ST(argvi) = sv_newmortal();
    sv_setnv(ST(argvi++), (double) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_estimateXA) {
    Model *arg0 ;
    double arg1 = 2.0 ;
    int argvi = 0;
    double result ;
    dXSARGS;
    
    if ((items < 1) || (items > 2)) 
    croak("Usage: Model_estimateXA(self,rho);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_estimateXA. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    if (items > 1) {
        arg1 = (double )SvNV(ST(1));
    }
    result = (double )arg0->estimateXA(arg1);
    ST(argvi) = sv_newmortal();
    sv_setnv(ST(argvi++), (double) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_compress) {
    Model *arg0 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_compress(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_compress. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (int )arg0->compress();
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_getSVnum) {
    Model *arg0 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_getSVnum(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_getSVnum. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (int )arg0->getSVnum();
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_getBSVnum) {
    Model *arg0 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_getBSVnum(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_getBSVnum. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (int )arg0->getBSVnum();
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_getTrainingDataSize) {
    Model *arg0 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_getTrainingDataSize(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_getTrainingDataSize. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (int )arg0->getTrainingDataSize();
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Model_getLoss) {
    Model *arg0 ;
    int argvi = 0;
    double result ;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: Model_getLoss(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of Model_getLoss. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (double )arg0->getLoss();
    ST(argvi) = sv_newmortal();
    sv_setnv(ST(argvi++), (double) result);
    XSRETURN(argvi);
}


XS(_wrap_new_Model) {
    int argvi = 0;
    Model *result ;
    dXSARGS;
    
    if ((items < 0) || (items > 0)) 
    croak("Usage: new_Model();");
    result = (Model *)new Model();
    ST(argvi) = sv_newmortal();
    SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Model);
    XSRETURN(argvi);
}


XS(_wrap_delete_Model) {
    Model *arg0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: delete_Model(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 1 of delete_Model. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    delete arg0;
    XSRETURN(argvi);
}


XS(_wrap_Example_read) {
    Example *arg0 ;
    char *arg1 ;
    char *arg2 = "r" ;
    int arg3 = 0 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 2) || (items > 4)) 
    croak("Usage: Example_read(self,char const *,mode,offset);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Example) < 0) {
        croak("Type error in argument 1 of Example_read. Expected %s", SWIGTYPE_p_Example->name);
        XSRETURN(1);
    }
    if (! SvOK((SV*) ST(1))) {
        arg1 = 0; 
    }
    else {
        arg1 = (char *) SvPV(ST(1),PL_na); 
    }
    if (items > 2) {
        if (! SvOK((SV*) ST(2))) {
            arg2 = 0; 
        }
        else {
            arg2 = (char *) SvPV(ST(2),PL_na); 
        }
    }
    if (items > 3) {
        arg3 = (int )SvIV(ST(3));
    }
    result = (int )arg0->read((char const *)arg1,(char const *)arg2,arg3);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Example_write) {
    Example *arg0 ;
    char *arg1 ;
    char *arg2 = "w" ;
    int arg3 = 0 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 2) || (items > 4)) 
    croak("Usage: Example_write(self,char const *,mode,offset);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Example) < 0) {
        croak("Type error in argument 1 of Example_write. Expected %s", SWIGTYPE_p_Example->name);
        XSRETURN(1);
    }
    if (! SvOK((SV*) ST(1))) {
        arg1 = 0; 
    }
    else {
        arg1 = (char *) SvPV(ST(1),PL_na); 
    }
    if (items > 2) {
        if (! SvOK((SV*) ST(2))) {
            arg2 = 0; 
        }
        else {
            arg2 = (char *) SvPV(ST(2),PL_na); 
        }
    }
    if (items > 3) {
        arg3 = (int )SvIV(ST(3));
    }
    result = (int )arg0->write((char const *)arg1,(char const *)arg2,arg3);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Example_rebuildSVindex) {
    Example *arg0 ;
    Model *arg1 ;
    int argvi = 0;
    int result ;
    dXSARGS;
    
    if ((items < 2) || (items > 2)) 
    croak("Usage: Example_rebuildSVindex(self,Model *);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Example) < 0) {
        croak("Type error in argument 1 of Example_rebuildSVindex. Expected %s", SWIGTYPE_p_Example->name);
        XSRETURN(1);
    }
    if (SWIG_ConvertPtr(ST(1),(void **) &arg1,SWIGTYPE_p_Model) < 0) {
        croak("Type error in argument 2 of Example_rebuildSVindex. Expected %s", SWIGTYPE_p_Model->name);
        XSRETURN(1);
    }
    result = (int )arg0->rebuildSVindex(arg1);
    ST(argvi) = sv_newmortal();
    sv_setiv(ST(argvi++),(IV) result);
    XSRETURN(argvi);
}


XS(_wrap_Example_learn) {
    Example *arg0 ;
    char *arg1 = 0 ;
    int argvi = 0;
    Model *result ;
    dXSARGS;
    
    if ((items < 1) || (items > 2)) 
    croak("Usage: Example_learn(self,s);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Example) < 0) {
        croak("Type error in argument 1 of Example_learn. Expected %s", SWIGTYPE_p_Example->name);
        XSRETURN(1);
    }
    if (items > 1) {
        if (! SvOK((SV*) ST(1))) {
            arg1 = 0; 
        }
        else {
            arg1 = (char *) SvPV(ST(1),PL_na); 
        }
    }
    result = (Model *)arg0->learn((char const *)arg1);
    ST(argvi) = sv_newmortal();
    SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Model);
    XSRETURN(argvi);
}


XS(_wrap_new_Example) {
    int argvi = 0;
    Example *result ;
    dXSARGS;
    
    if ((items < 0) || (items > 0)) 
    croak("Usage: new_Example();");
    result = (Example *)new Example();
    ST(argvi) = sv_newmortal();
    SWIG_MakePtr(ST(argvi++), (void *) result, SWIGTYPE_p_Example);
    XSRETURN(argvi);
}


XS(_wrap_delete_Example) {
    Example *arg0 ;
    int argvi = 0;
    dXSARGS;
    
    if ((items < 1) || (items > 1)) 
    croak("Usage: delete_Example(self);");
    if (SWIG_ConvertPtr(ST(0),(void **) &arg0,SWIGTYPE_p_Example) < 0) {
        croak("Type error in argument 1 of delete_Example. Expected %s", SWIGTYPE_p_Example->name);
        XSRETURN(1);
    }
    delete arg0;
    XSRETURN(argvi);
}



/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (BEGIN) -------- */

static void *_p_ExampleTo_p_BaseExample(void *x) {
    return (void *)((BaseExample *) ((Example *) x));
}
static void *_p_ModelTo_p_BaseExample(void *x) {
    return (void *)((BaseExample *) ((Model *) x));
}
static swig_type_info _swigt__p_BaseExample[] = {{"TinySVM::BaseExample", 0, "BaseExample *"},{"TinySVM::BaseExample"},{"TinySVM::Example", _p_ExampleTo_p_BaseExample},{"TinySVM::Model", _p_ModelTo_p_BaseExample},{0}};
static swig_type_info _swigt__p_Example[] = {{"TinySVM::Example", 0, "Example *"},{"TinySVM::Example"},{0}};
static swig_type_info _swigt__p_Model[] = {{"TinySVM::Model", 0, "Model *"},{"TinySVM::Model"},{0}};

static swig_type_info *swig_types_initial[] = {
_swigt__p_BaseExample, 
_swigt__p_Example, 
_swigt__p_Model, 
0
};


/* -------- TYPE CONVERSION AND EQUIVALENCE RULES (END) -------- */

XS(_wrap_perl5_TinySVM_var_init) {
    dXSARGS;
    SV *sv;
    XSRETURN(1);
}
#ifdef __cplusplus
extern "C"
#endif
XS(SWIG_init) {
    dXSARGS;
    int i;
    char *file = (char *) __FILE__;
    for (i = 0; swig_types_initial[i]; i++) {
        swig_types[i] = SWIG_TypeRegister(swig_types_initial[i]);
    }
    newXS((char *) "TinySVMc::var_TinySVM_init", _wrap_perl5_TinySVM_var_init, file);
    newXS((char *) "TinySVMc::BaseExample_add", _wrap_BaseExample_add, file);
    newXS((char *) "TinySVMc::BaseExample_set", _wrap_BaseExample_set, file);
    newXS((char *) "TinySVMc::BaseExample_get", _wrap_BaseExample_get, file);
    newXS((char *) "TinySVMc::BaseExample_remove", _wrap_BaseExample_remove, file);
    newXS((char *) "TinySVMc::BaseExample_clear", _wrap_BaseExample_clear, file);
    newXS((char *) "TinySVMc::BaseExample_size", _wrap_BaseExample_size, file);
    newXS((char *) "TinySVMc::BaseExample_read", _wrap_BaseExample_read, file);
    newXS((char *) "TinySVMc::BaseExample_write", _wrap_BaseExample_write, file);
    newXS((char *) "TinySVMc::BaseExample_readSVindex", _wrap_BaseExample_readSVindex, file);
    newXS((char *) "TinySVMc::BaseExample_writeSVindex", _wrap_BaseExample_writeSVindex, file);
    newXS((char *) "TinySVMc::delete_BaseExample", _wrap_delete_BaseExample, file);
    newXS((char *) "TinySVMc::BaseExample_append", _wrap_BaseExample_append, file);
    newXS((char *) "TinySVMc::BaseExample_appendSVindex", _wrap_BaseExample_appendSVindex, file);
    newXS((char *) "TinySVMc::BaseExample_getDimension", _wrap_BaseExample_getDimension, file);
    newXS((char *) "TinySVMc::BaseExample_getNonzeroDimension", _wrap_BaseExample_getNonzeroDimension, file);
    newXS((char *) "TinySVMc::BaseExample_getY", _wrap_BaseExample_getY, file);
    newXS((char *) "TinySVMc::BaseExample_getX", _wrap_BaseExample_getX, file);
    newXS((char *) "TinySVMc::BaseExample_getAlpha", _wrap_BaseExample_getAlpha, file);
    newXS((char *) "TinySVMc::BaseExample_getGradient", _wrap_BaseExample_getGradient, file);
    newXS((char *) "TinySVMc::BaseExample_getG", _wrap_BaseExample_getG, file);
    newXS((char *) "TinySVMc::Model_read", _wrap_Model_read, file);
    newXS((char *) "TinySVMc::Model_write", _wrap_Model_write, file);
    newXS((char *) "TinySVMc::Model_clear", _wrap_Model_clear, file);
    newXS((char *) "TinySVMc::Model_classify", _wrap_Model_classify, file);
    newXS((char *) "TinySVMc::Model_estimateMargin", _wrap_Model_estimateMargin, file);
    newXS((char *) "TinySVMc::Model_estimateSphere", _wrap_Model_estimateSphere, file);
    newXS((char *) "TinySVMc::Model_estimateVC", _wrap_Model_estimateVC, file);
    newXS((char *) "TinySVMc::Model_estimateXA", _wrap_Model_estimateXA, file);
    newXS((char *) "TinySVMc::Model_compress", _wrap_Model_compress, file);
    newXS((char *) "TinySVMc::Model_getSVnum", _wrap_Model_getSVnum, file);
    newXS((char *) "TinySVMc::Model_getBSVnum", _wrap_Model_getBSVnum, file);
    newXS((char *) "TinySVMc::Model_getTrainingDataSize", _wrap_Model_getTrainingDataSize, file);
    newXS((char *) "TinySVMc::Model_getLoss", _wrap_Model_getLoss, file);
    newXS((char *) "TinySVMc::new_Model", _wrap_new_Model, file);
    newXS((char *) "TinySVMc::delete_Model", _wrap_delete_Model, file);
    newXS((char *) "TinySVMc::Example_read", _wrap_Example_read, file);
    newXS((char *) "TinySVMc::Example_write", _wrap_Example_write, file);
    newXS((char *) "TinySVMc::Example_rebuildSVindex", _wrap_Example_rebuildSVindex, file);
    newXS((char *) "TinySVMc::Example_learn", _wrap_Example_learn, file);
    newXS((char *) "TinySVMc::new_Example", _wrap_new_Example, file);
    newXS((char *) "TinySVMc::delete_Example", _wrap_delete_Example, file);
    ST(0) = &PL_sv_yes;
    XSRETURN(1);
}