array.c

使用具有增量学习的监控式学习方法。包括几个不同的分类算法。

/* Copyright (C) 2001-2002  Mikael Ylikoski
 * See the accompanying file "README" for the full copyright notice */
/**
 * @file
 * Dynamic arrays.
 *
 * @author  Mikael Ylikoski
 * @date    2001-2002
 */

#include <stdlib.h>
#include <string.h>

#ifndef ARRAY_NAME
#define ARRAY_FUNC(x) typearray##x
#define ARRAY_NAME typearray
#define ARRAY_TYPE type
#include "array.h"
#endif


/**
 * Find position of a value in an array
 *
 * @param a    array to search in
 * @param val  value to search for
 * @return The position of the value, or -1 if the value is not found.
 */
static int
find_position (ARRAY_NAME *a, ARRAY_TYPE val) {
    int i;

    for (i = 0; i < a->nov; i++)
	if (a->value[i] == val)
	    return i;
    return -1;
}


/**
 * Create a new empty array.
 *
 * @param size  initial size of array
 * @return The array, or NULL if memory allocation failed.
 */
ARRAY_NAME *
ARRAY_FUNC(_new) (int size) {
    ARRAY_NAME *a;

    a = malloc (sizeof(ARRAY_NAME));
    if (!a)
	return NULL;

    if (size) {
	a->value = calloc (size, sizeof(ARRAY_TYPE));
	if (!a->value) {
	    free (a);
	    return NULL;
	}
    } else
	a->value = NULL;
    a->sov = size;
    a->nov = 0;

    return a;
}


/**
 * Copy an array.
 *
 * @param a  array to copy.
 * @return The new array.
 */
ARRAY_NAME *
ARRAY_FUNC(_copy) (ARRAY_NAME *a) {
    ARRAY_NAME *na;

    na = malloc (sizeof(ARRAY_NAME));
    if (!na)
	return NULL;

    na->sov = a->nov;
    na->nov = a->nov;
    if (na->nov) {
	na->value = calloc (a->nov, sizeof(ARRAY_TYPE));
	if (!na->value) {
	    free(na);
	    return NULL;
	}
	memcpy (na->value, a->value, a->nov * sizeof(ARRAY_TYPE));
    } else
	na->value = NULL;

    return na;
}


/**
 * Free an array.
 *
 * @param a  array to free
 */
void
ARRAY_FUNC(_free) (ARRAY_NAME *a) {
    if (!a)
	return;
    free (a->value);
    free (a);
}


/**
 * Set the size of an array.
 *
 * @param a     array to operate on
 * @param size  new size
 * @return Zero if ok, or -1 if memory allocation failed.
 */
int
ARRAY_FUNC(_set_size) (ARRAY_NAME *a, int size) {
    ARRAY_TYPE *va;

    if (size > a->sov) {
	va = realloc (a->value, size * sizeof(ARRAY_TYPE));
	if (!va)
	    return -1;
	memset (&va[a->sov], 0, (size - a->sov) * sizeof(ARRAY_TYPE));
	a->value = va;
	a->sov = size;
    }
    a->nov = size;

    return 0;
}


/**
 * Set a value of an array.
 * The array is enlarged if necessary.
 *
 * @param a    array to insert into
 * @param pos  position to insert to
 * @param val  value to insert
 * @return Zero if ok, or -1 if memory allocation failed.
 */
int
ARRAY_FUNC(_put_value) (ARRAY_NAME *a, int pos, ARRAY_TYPE val) {
    ARRAY_TYPE *va;

    if (pos >= a->sov) {
	va = realloc (a->value, (pos + 1) * sizeof(ARRAY_TYPE));
	if (!va)
	    return -1;
	memset (&va[a->sov], 0, (pos + 1 - a->sov) * sizeof(ARRAY_TYPE));
	a->value = va;
	a->sov = pos + 1;
    }

    if (pos >= a->nov)
	a->nov = pos + 1;

    a->value[pos] = val;

    return 0;
}


/**
 * Insert a value into an array.
 *
 * @param a    array to insert into
 * @param pos  position to insert to
 * @param val  value to insert
 * @return Zero if ok, or -1 if memory allocation failed.
 */
int
ARRAY_FUNC(_insert) (ARRAY_NAME *a, int pos, ARRAY_TYPE val) {
    ARRAY_TYPE *va;
    int i;

    if (pos >= a->sov) {
	va = realloc (a->value, (pos + 1) * sizeof(ARRAY_TYPE));
	if (!va)
	    return -1;
	memset (&va[a->sov], 0, (pos + 1 - a->sov) * sizeof(ARRAY_TYPE));
	a->value = va;
	a->sov = pos + 1;
    } else if (a->nov == a->sov) {
	va = realloc (a->value, (a->sov + 5) * sizeof(ARRAY_TYPE));
	if (!va)
	    return -1;
	memset (&va[a->sov], 0, 5 * sizeof(ARRAY_TYPE));
	a->value = va;
	a->sov += 5;
    }

    for (i = a->nov; i > pos; i--)
	a->value[i] = a->value[i - 1];

    a->value[pos] = val;
    if (pos >= a->nov)
	a->nov = pos + 1;
    else
	a->nov++;

    return 0;
}


/**
 * Append a value to the end of an array.
 *
 * @param a    array to append to
 * @param val  value to append
 * @return Zero if ok, or -1 if memory allocation failed.
 */
int
ARRAY_FUNC(_append) (ARRAY_NAME *a, ARRAY_TYPE val) {
    ARRAY_TYPE *va;

    if (a->nov == a->sov) {
	va = realloc (a->value, (a->sov + 5) * sizeof(ARRAY_TYPE));
	if (!va)
	    return -1;
	memset (&va[a->sov], 0, 5 * sizeof(ARRAY_TYPE));
	a->value = va;
	a->sov += 5;
    }

    a->value[a->nov++] = val;

    return 0;
}


/**
 * Remove a position from an array.
 *
 * @param a    array to remove from
 * @param pos  position to remove
 * @return Zero if ok, or -1 if the position is out of bounds.
 */
int
ARRAY_FUNC(_remove) (ARRAY_NAME *a, int pos) {
    if (pos >= a->nov)
	return -1;
#if 1
    for (a->nov--; pos < a->nov; pos++)
	a->value[pos] = a->value[pos + 1];
#else
    memmove (&a->value[pos], &a->value[pos + 1],
	     (--a->nov - pos) * sizeof(ARRAY_TYPE));
#endif

    return 0;
}


/**
 * Remove a value from an array.
 *
 * @param a    array to remove from
 * @param val  value to remove
 * @return Zero if ok, or -1 if the value was not found.
 */
int
ARRAY_FUNC(_remove_value) (ARRAY_NAME *a, ARRAY_TYPE val) {
    int pos;

    pos = find_position (a, val);
    if (pos == -1)
	return -1;

    for (a->nov--; pos < a->nov; pos++)
	a->value[pos] = a->value[pos + 1];

    return 0;
}


ARRAY_TYPE
ARRAY_FUNC(_pop_value) (ARRAY_NAME *a) {
    if (a->nov > 0)
	return a->value[--a->nov];
    return (ARRAY_TYPE)0;
}