gensvm_base.c

Go to the documentation of this file.

#include "gensvm_base.h"

struct GenData *gensvm_init_data(void)
{
    struct GenData *data = Malloc(struct GenData, 1);
    data->Sigma = NULL;
    data->y = NULL;
    data->Z = NULL;
    data->spZ = NULL;
    data->RAW = NULL;

    // set default values
    data->kerneltype = K_LINEAR;
    data->gamma = -1;
    data->coef = -1;
    data->degree = -1;

    return data;
}

void gensvm_free_data(struct GenData *data)
{
    if (data == NULL)
        return;

    if (data->spZ != NULL)
        gensvm_free_sparse(data->spZ);

    if (data->Z == data->RAW) {
        free(data->Z);
    } else {
        free(data->Z);
        free(data->RAW);
    }
    free(data->y);
    free(data->Sigma);
    free(data);
    data = NULL;
}

struct GenModel *gensvm_init_model(void)
{
    struct GenModel *model = Malloc(struct GenModel, 1);

    // set default values
    model->p = 1.0;
    model->lambda = pow(2, -8.0);
    model->epsilon = 1e-6;
    model->kappa = 0.0;
    model->weight_idx = 1;
    model->gamma = 1.0;
    model->coef = 0.0;
    model->degree = 2.0;
    model->kerneltype = K_LINEAR;
    model->kernel_eigen_cutoff = 1e-8;
    model->max_iter = 1000000000;
    model->training_error = -1;
    model->elapsed_iter = -1;
    model->status = -1;

    model->V = NULL;
    model->Vbar = NULL;
    model->U = NULL;
    model->UU = NULL;
    model->Q = NULL;
    model->H = NULL;
    model->rho = NULL;
    model->data_file = NULL;

    return model;
}

void gensvm_allocate_model(struct GenModel *model)
{
    long n = model->n;
    long m = model->m;
    long K = model->K;

    model->V = Calloc(double, (m+1)*(K-1));
    model->Vbar = Calloc(double, (m+1)*(K-1));
    model->U = Calloc(double, K*(K-1));
    model->UU = Calloc(double, K*K*(K-1));
    model->Q = Calloc(double, n*K);
    model->H = Calloc(double, n*K);
    model->rho = Calloc(double, n);
}

void gensvm_reallocate_model(struct GenModel *model, long n, long m)
{
    long K = model->K;

    if (model->n == n && model->m == m)
        return;
    if (model->n != n) {
        model->Q = Realloc(model->Q, double, n*K);
        Memset(model->Q, double, n*K);

        model->H = Realloc(model->H, double, n*K);
        Memset(model->H, double, n*K);

        model->rho = Realloc(model->rho, double, n);
        Memset(model->rho, double, n);

        model->n = n;
    }
    if (model->m != m) {
        model->V = Realloc(model->V, double, (m+1)*(K-1));
        Memset(model->V, double, (m+1)*(K-1));

        model->Vbar = Realloc(model->Vbar, double, (m+1)*(K-1));
        Memset(model->Vbar, double, (m+1)*(K-1));

        model->m = m;
    }
}

void gensvm_free_model(struct GenModel *model)
{
    if (model == NULL)
        return;

    free(model->V);
    free(model->Vbar);
    free(model->U);
    free(model->UU);
    free(model->Q);
    free(model->H);
    free(model->rho);
    free(model->data_file);

    free(model);
    model = NULL;
}

struct GenWork *gensvm_init_work(struct GenModel *model)
{
    long n = model->n;
    long m = model->m;
    long K = model->K;

    struct GenWork *work = Malloc(struct GenWork, 1);
    work->n = n;
    work->m = m;
    work->K = K;

    work->LZ = Calloc(double, n*(m+1));
    work->ZB = Calloc(double, (m+1)*(K-1)),
    work->ZBc = Calloc(double, (m+1)*(K-1)),
    work->ZAZ = Calloc(double, (m+1)*(m+1)),
    work->tmpZAZ = Calloc(double, (m+1)*(m+1)),
    work->ZV = Calloc(double, n*(K-1));
    work->beta = Calloc(double, K-1);

    return work;
}

void gensvm_free_work(struct GenWork *work)
{
    free(work->LZ);
    free(work->ZB);
    free(work->ZBc);
    free(work->ZAZ);
    free(work->tmpZAZ);
    free(work->ZV);
    free(work->beta);
    free(work);
    work = NULL;
}

void gensvm_reset_work(struct GenWork *work)
{
    long n = work->n;
    long m = work->m;
    long K = work->K;

    Memset(work->LZ, double, n*(m+1));
    Memset(work->ZB, double, (m+1)*(K-1)),
    Memset(work->ZBc, double, (m+1)*(K-1)),
    Memset(work->ZAZ, double, (m+1)*(m+1)),
    Memset(work->tmpZAZ, double, (m+1)*(m+1)),
    Memset(work->ZV, double, n*(K-1));
    Memset(work->beta, double, K-1);
}