distortion

Digital Signal Processing Library

Voice Lab

distortion

double distortion(double **cb_vector, int cb_length, int vector_width, double **vector, int number_vectors, int *vector_index, int options)
{
        int i, opt;
        double total_distortion;

        // vector_classify(cb_vector, cb_length, vector_width, vector, number_vectors, vector_index);

        total_distortion = 0.0;

        //if(opt == 0)  distance = distance;
        //if(opt == 2)  distance = sqrt(distance);
        //if(opt == 8)  distance /= vector_width;
        opt = 2;

        for(i = 0; i < number_vectors; i++) {
                total_distortion += vector_distance(vector[i], cb_vector[vector_index[i]], vector_width, opt);
                number_adds++;
        }

        number_adds--;

        /*
        ** Compensate the number of additions, subtractions, and multiplications
        ** that are not necessary for the total distortion calculation
        */

        for(i = 0; i < (number_vectors*vector_width); i++) {
                number_subs--;
                number_muls--;
        }

        for(i = 0; i < (number_vectors*(vector_width-1)); i++) {
                number_adds--;
        }

        if(options == 1) total_distortion /= number_vectors;

        return(total_distortion);
}

centroid

Digital Signal Processing Library

Voice Lab

centroid

void centroid(double **cb_vector, int cb_length, int vector_width, double **vector, int number_vectors, int *vector_index)
{
        int i, j;
        int *number_class; /* stores the number of vectors in each class */
        double *temp_vector, **temp_matrix, *temp_matrix_data_ptr;
        int temp_vectors_max;

        // vector_classify(cb_vector, cb_length, vector_width, vector, number_vectors, vector_index);

        /* Allocate temporary vector */
        vector_allocate(&temp_vector, vector_width);

        /* Allocate temporary matrix data pointer for temporary codebook */
        temp_vectors_max = cb_length;
        matrix_allocate(&temp_matrix, &temp_matrix_data_ptr, vector_width, &temp_vectors_max);

        /* Clear matrix */
        for(i = 0; i < cb_length; i++) {
                for(j = 0; j < vector_width; j++) {
                        temp_matrix[i][j] = 0.0;
                }
        }

        /* add the vectors in each cloud */
        for(i = 0; i < number_vectors; i++) {
                vector_add(temp_matrix[vector_index[i]], vector[i], vector_width, &temp_matrix[vector_index[i]]);
        }

        /* Compensate for the vector_add routine */
        for(i = 0; i < cb_length; i++) {
                for(j = 0; j < (vector_width - 1); j++) {
                        number_adds--;
                }
        }

        /* Allocate number_class array */
        number_class = malloc(cb_length * sizeof(int));
        if(number_class == NULL) {
                fprintf(stderr, "Error allocating memory (centroid - number_class)\n");
                exit(1);
        }

        /* clear class_number array */
        for(i = 0; i < cb_length; i++) {
                number_class[i] = 0;
                number_adds--;
        }

        /* count vector in each cloud */
        for(i = 0; i < number_vectors; i++) {
                number_class[vector_index[i]]++;
                number_adds++;
        }

        /* divide each cloud sum, by number of vectors in each cloud */
        for(i = 0; i < cb_length; i++) {
                for(j = 0; j < vector_width; j++){
                        temp_vector[j] = temp_matrix[i][j];
                        if(number_class[i] != 0) {
                                temp_matrix[i][j] = temp_vector[j]/number_class[i];
                        }
                        number_divs++;
                }
        }

        for(i = 0; i < cb_length; i++) {
                if(number_class[i] != 0) {
                        /* copy temp_matrix to cb_vector */
                        vector_copy(temp_matrix[i], vector_width, &cb_vector[i]);
                }
        }
        free(temp_vector);
        free(number_class);
        free(temp_matrix_data_ptr);
        free(temp_matrix);
        return;
}

vector_classify

Digital Signal Processing Library

Voice Lab

vector_classify

void vector_classify(double **cb_vector, int cb_length, int vector_width, double **vector, int number_vectors, int *vector_index)
{
        int i, j, options;
        double distance, distance_index;

        //if(options == 0)  distance = distance;
        //if(options == 2)  distance = sqrt(distance);
        //if(options == 8)  distance /= vector_width;
        options = 2;

        for(i = 0; i < number_vectors; i++) {
                /* set initial distance equal to the first codebook vector */
                distance_index = vector_distance(cb_vector[0], vector[i], vector_width, options);

                /* set initial vector equal to first codebook vector */
                vector_index[i] = 0;

                /* for each additional codebook vecto, see if the distance is shorter */
                for(j = 1; j < cb_length; j++) {
                        distance = vector_distance(cb_vector[j], vector[i], vector_width, options);
                        number_comps++;
                        if(distance < distance_index) {
                                distance_index = distance;
                                vector_index[i] = j;
                        }
                }
        }
        return;
}

vector_split

Digital Signal Processing Library

Voice Lab

vector_split

void vector_split(double *vector1, double delta, int vector_length, double **vector_2, double **vector_3)
{
        double aux;

        aux = 1.0 + delta;
        vector_multiply(vector1, aux, vector_length, vector_2);

        aux = 1.0 - delta;
        vector_multiply(vector1, aux, vector_length, vector_3);
        return;
}

vector_multiply

Digital Signal Processing Library

Voice Lab

vector_multiply

void vector_multiply(double *vector1, double value, int vector_width, double **vector2)
{
        int i;

        if(vector_width > MAX_VECTOR_WIDTH) {
                fprintf(stderr, "vector_width greater than MAX_VECTOR_WIDTH\n");
                fprintf(stderr, "Please increase MAX_VECTOR_WIDTH in vector_lib.h and recompile.\n");
                exit(-1);
        }

        for(i = 0; i < vector_width; i++){
                (*vector2)[i] = vector1[i] * value;
                number_muls++;
        }
        return;
}

vector_add

Digital Signal Processing Library

Voice Lab

vector_add

void vector_add(double *vector1, double *vector2, int vector_width, double **vector3)
{
        int i;

        if(vector_width > MAX_VECTOR_WIDTH) {
                fprintf(stderr, "vector_width greater than MAX_VECTOR_WIDTH\n");
                fprintf(stderr, "Please increase MAX_VECTOR_WIDTH in vector_lib.h and recompile.\n");
                exit(-1);
        }

        for(i = 0; i < vector_width; i++){
                (*vector3)[i] = vector1[i] + vector2[i];
                number_adds++;
        }
        return;
}

vector_copy

Digital Signal Processing Library

Voice Lab

vector_copy

void vector_copy(double *vector1, int vector_width, double **vector2)
{
        int i;

        if(vector_width > MAX_VECTOR_WIDTH) {
                fprintf(stderr, "vector_width greater than MAX_VECTOR_WIDTH\n");
                fprintf(stderr, "Please increase MAX_VECTOR_WIDTH in vector_lib.h and recompile.\n");
                exit(-1);
        }

        for(i = 0; i < vector_width; i++){
                (*vector2)[i] = vector1[i];
        }
        return;
}

cat_vector

Digital Signal Processing Library

Voice Lab

cat_vector

int cat_vector(double ***vector, double **vector_data_ptr,\
 int vector_width, int num_vectors_o, int *number_vectors_max,\
 double **vector_i, int num_vectors_i)
{
        int i, j;

        for(i = 0; i < num_vectors_i; i++) {
                if(num_vectors_o == (*number_vectors_max)) {
                        /* increase maximum number of vectors permitted */
                        matrix_reallocate(&(*vector), &(*vector_data_ptr),\
 vector_width, number_vectors_max);
                }
                vector_copy(vector_i[i], vector_width,\
 &((*vector)[num_vectors_o]));
                num_vectors_o++;
        }
        return(num_vectors_o);
}

matrix_reallocate

Digital Signal Processing Library

Voice Lab

matrix_reallocate

void matrix_reallocate(double ***matrix, double **matrix_data_ptr, int vector_width, int *number_vectors_max)
{
        int i;

        /* increase maximum number of vectors permitted */
        (*number_vectors_max) += ADDITIONAL_QUANTITY;

        /* reallocate space for reading in the additional vectors */
        (*matrix_data_ptr) = realloc((*matrix_data_ptr), (*number_vectors_max) * vector_width * sizeof(double));
        if((*matrix_data_ptr) == NULL) {
                fprintf(stderr, "Cannot allocate memory for data\n");
                exit(1);
        }

        /* reallocate space for pointers to the additional vectors */
        *matrix = realloc(*matrix, (*number_vectors_max) * sizeof(double *));
        if(*matrix == NULL) {
                fprintf(stderr, "Cannot allocate memory for data\n");
                exit(1);
        }

        /* set pointers to point to array of data */
        for(i = 0; i < (*number_vectors_max); i++) {
                (*matrix)[i] = (*matrix_data_ptr) + (i * vector_width);
        }
}

matrix_allocate

Digital Signal Processing Library

Voice Lab

matrix_allocate

void matrix_allocate(double ***matrix, double **matrix_data_ptr, int vector_width, int *number_vectors_max)
{
        int i;

        /* allocate space for reading in the vectors */
        (*matrix_data_ptr) = malloc((*number_vectors_max) * vector_width * sizeof(double));
        if((*matrix_data_ptr) == NULL) {
                fprintf(stderr, "Cannot allocate memory for data\n");
                exit(1);
        }

        /* allocate space for pointers to the vectors */
        *matrix = malloc((*number_vectors_max) * sizeof(double *));
        if(*matrix == NULL) {
                fprintf(stderr, "Cannot allocate memory for data\n");
                exit(1);
        }

        /* set pointers to point to array of data */
        for(i = 0; i < (*number_vectors_max); i++) {
                (*matrix)[i] = (*matrix_data_ptr) + (i * vector_width);
        }
}

vector_allocate

Digital Signal Processing Library

Voice Lab

vector_allocate

void vector_allocate(double **vector, int vector_width)
{
        (*vector) = malloc(vector_width * sizeof(double));
        if((*vector) == NULL) {
                fprintf(stderr, "Cannot allocate memory for data\n");
                exit(1);
        }
}

vector_distance

Digital Signal Processing Library

Voice Lab

vector_distance

double vector_distance(double *vector1, double *vector2, int vector_width, int options)
{
        int i, offset;
        double distance, diff;

        /* Euclidean distance is defined as the square root of the square of the diferences of each element */
        /* For this routine to return the Euclidean distance between two vectors, OPTIONS must be set to two */

        /* Information taken from Douglas O'Shaughnessy's book */
        /*   "Speech Communication, Human and Machine" 1990, page 315 equation 7.31 */

        /* start with zero distance */
        distance = 0.0;

        offset = options & 0x01;

        for(i = offset; i < (vector_width+offset); i++) {
                /* add the square of the distance between each element of the vectors */
                diff = (vector1[i] - vector2[i]);
                distance += (diff * diff);
                number_subs++;
                number_muls++;
                number_adds++;
        }
        number_adds--; /* compensate the first add with zero ??? */

        if(options & 0x02)  distance = sqrt(distance);
        if(options & 0x08)  distance /= vector_width;

        return(distance);
}

free_vectors

Digital Signal Processing Library

Voice Lab

free_vectors

void free_vectors(double ***vector, double **vector_data_ptr)
{
        free(*vector);
        free(*vector_data_ptr);
        return;
}

read_vector_file

Digital Signal Processing Library

Voice Lab

read_vector_file

int read_vector_file(double ***vector, double **vector_data_ptr,\
 int vector_width, int *number_vectors_max, char *file_name)
{
        double y;
        int number_vectors = 0;
        int i, j, k;
        FILE *input;

        if((*number_vectors_max) == 0) (*number_vectors_max) = VECTOR_QUANTITY;

        if((input = fopen(file_name,"rb")) == NULL) {
                //printf("File not found\n");
                exit(1);
        } else {
                //printf("File opened for reading\n");
        }

        /* allocate space for reading in the vectors */
        matrix_allocate(&(*vector), &(*vector_data_ptr), vector_width, number_vectors_max);

        do {
                if(number_vectors == (*number_vectors_max)) {
                        /* increase maximum number of vectors permitted */
                        matrix_reallocate(&(*vector), &(*vector_data_ptr),\
 vector_width, number_vectors_max);
                }
                k = 1;
                /* read in the individual values for each vector */
                for(j = 0; (j < vector_width) && (k == 1); j++) {
                        k = fscanf(input, "%lf", &y);
                        if(k == 1) {
                                (*vector)[number_vectors][j] = y;
                        }
                }
                if(k == 1) {
                        /* if vector read, bump counter */
                        number_vectors++;
                }
        } while(k == 1);

        fclose(input);

        return(number_vectors);
}