¡Buenas!

La verdad es que bucear en un código ajeno es una locura.

Veo cosas raras como esta:

vector* create_vector( int n, float* data ) {
        vector* v;
        v = (vector*) malloc(sizeof( vector )); //creamos un puntero a una instancia del struct        
        v->data = data;                                        
        v->dim = n;                                     //inicializamos dim de v, numero de posiciones
        return v;                                       //devolvemos v
}
 
//...
void destroy_vector( vector* v ) {
        free( v->data );
        free( v );              //desalojamos la memoria reservada
 
}
 

A los datos les estás asignando un vector ajeno a la estructura, pero luego intentas liberar la memoria dentro de la propia estructura. La verdad es que no es coherente. Si el vector de datos es un vector exterior a la estructura, libera su memoria fuera de la estructura, o lo que me parece más lógico, crea dentro de la estructura de datos la memoria suficiente para almacenar los datos del vector que pasas en el "constructor" y luego copias su contenido en la memoria que acabas de reservar. Así tienes localizada cualquier asignación dinámica de memoria dentro de la propia estructura de datos y todo está más claro.

La cosa quedaría algo así:

vector* create_vector( int n, float* data ) {
        vector* v;
        v = (vector*) malloc(sizeof( vector )); //creamos un puntero a una instancia del struct 
        v->data = (float*) malloc(n * sizeof(float));
        memcpy(v->data, data, n * sizeof(float));
        v->dim = n;                                     //inicializamos dim de v, numero de posiciones
        return v;                                       //devolvemos v
}
 

Luego, si el parámetro data que recibe esta función ha sido creado utilizando memoria dinámica, la liberas cuando esa variable no te haga mas falta o antes de que salga de su ámbito.

Si ordenas bien las ideas y el código te ahorraras bastantes quebraderos de cabeza. Revisa bien el código viendo donde asignas memoria y comprobando que liberas toda la que asignas.

¡Saludos!

PD: Te dejo un código un poco más claro para una de las funciones:

int contarcomas(char* cadena){
        int j = 1;                            //inicializando en 1 nos ahorramos contar el primer carácter que es un [
        int c = 1;                            // numero de comas                                  
        while(cadena[j] != ']'){              //contar comas
                if(cadena[j++] == ','){ //Siempre hay que incrementar j. Lo hacemos directamente aquí.
                        c++;
                }
        }
        return c;
}
 

¡Saludos!