/*
 *  vector.c
 *
 *	Scott Wilson
 *	rswilson@ccrma.stanford.edu
 *  last updated:  June 15, 2003
 *
 *
 */

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

#include "vector.h"

codec_err_t vector_alloc(uint32_t size, codec_vector_p *vector) {
    *vector = (codec_vector_p)malloc(sizeof(_codec_vector_t) * size);
    if (! *vector) {
        codec_error("core", "codec_vector_alloc", strerror(errno));
        return (codec_err_t)errno;
    }
    memset((void *)*vector, 0, sizeof(_codec_vector_t));
    return ERR_NONE;
}

codec_err_t vector_set_alloc(uint32_t size, uint8_t chans, codec_vector_set_p *vector) {
    int i;
    codec_err_t err;
    codec_vector_p *nvec;

    *vector = (codec_vector_p *)malloc(sizeof(codec_vector_p) * chans);
    if (! *vector) {
        codec_error("core", "codec_vector_alloc", strerror(errno));
        return (codec_err_t)errno;
    }
    nvec = *vector;

    for (i=0; i<chans; i++) {
        err = vector_alloc(size, &nvec[i]);
        if (err) {
            int j;
            for (j=0; j<i; j++)
                vector_dealloc(nvec[j]);
            free(nvec);
        }
    }
    return ERR_NONE;
}

codec_err_t vector_clear(codec_vector_p vector, uint32_t size) {
    memset((void *)vector, 0, size*sizeof(_codec_vector_t));
    return ERR_NONE;
}

codec_err_t vector_set_clear(codec_vector_set_p vector, uint32_t size, uint8_t chans) {
    int i;
    codec_err_t err;

    for (i=0; i<chans; i++) {
        err = vector_clear(vector[i], size);
        if (err)
            return err;
    }
    return ERR_NONE;
}

codec_err_t vector_dealloc(codec_vector_p vector) {
    free(vector);
    return ERR_NONE;
}

codec_err_t vector_set_dealloc(codec_vector_set_p vector, uint8_t chans) {
    int i;
    codec_err_t err;

    for (i=0; i<chans; i++) {
        err = vector_dealloc(vector[i]);
        if (err)
            return err;
    }
    free(vector);
    return ERR_NONE;
}

codec_float_t vector_sum(codec_vector_p signal, uint16_t blocksize) {
    int i;
    codec_float_t sum = 0.0;
    for (i=0; i<blocksize; i++) {
        sum += signal[i];
    }
    return sum;
}

codec_float_t vector_max(codec_vector_p signal, uint16_t blocksize) {
    int i;
    codec_float_t big = signal[0];
    for (i=0; i<blocksize; i++) {
        if (signal[i] > big) big = signal[i];
    }
    return big;
}

codec_float_t vector_abs_max(codec_vector_p signal, uint16_t blocksize) {
    int i;
    codec_float_t big = fabs(signal[0]);
    for (i=0; i<blocksize; i++) {
        if (fabs(signal[i]) > big) big = fabs(signal[i]);
    }
    return big;
}

codec_err_t vector_scale(codec_vector_p signal, uint16_t blocksize, codec_float_t scale_factor) {
    int i;
    for (i=0; i<blocksize; i++) {
        signal[i] *= scale_factor;
    }
    return ERR_NONE;
}

codec_err_t vector_square(codec_vector_p signal, uint16_t blocksize) {
    int i;
    for (i=0; i<blocksize; i++) {
        signal[i] = signal[i] * signal[i];
    }
    return ERR_NONE;
}

codec_err_t vector_subtract(codec_vector_p v1, codec_vector_p v2, uint16_t blocksize) {
    int i;
    for (i=0; i<blocksize; i++) {
        v1[i] = v2[i] - v1[i];
    }
    return ERR_NONE;
}