[C] Array e allocazione dinamica

[bad.alex]

Ragazzi, sto svolgendo un esercizio:
"Si considerino due array VL[ ] e VR[ ] di n elementi di tipo double, allocati dinamicamente e con n
inserito da tastiera, riempito di numeri casuali generati secondo la formula:
(rand()%1500 + 1)/1500.0
Si supponga che tali array siano relativi alle velocita' della ruota sinistra e destra di un veicolo a due
ruote in moto in uno spazio bidimensionale; supporre che i valori siano campionati ogni ogni 10
millisecondi (T=102).
1. Scrivere una funzione che restituisce tre nuovi array x[ ], y[ ] e alpha[ ] allocati dinamicamente,
calcolati nel seguente modo:

$x_[i+1]=x_+(v_r_+v_l_)/2*T*cos(alpha_);
y_[i+1]=y_+(v_r_+v_l_)/2*T*sin(alpha_);
alpha_[i+1]=alpha_+(v_r_-v_l_)/0.6*T; $



Scrivere due funzioni ognuna delle quali determina e restituisce:
1. la lunghezza complessiva della traiettoria percorsa
2. il numero di volte in cui il veicolo attraversa l'asse X "

Sinora ho cercato di svolgere il primo punto. Ed effettivamente sino alla generazione dei vettori riempiti con valori casuali è tutto ok.
Il problema nasce nel momento in cui voglio allocare tre nuovi vettori e restituirne il valore.
Il codice è il seguente:

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <math.h>

#define T 0.01

/* Dichiarazione funzioni */

void riempi_vettore ( double *, int );
double new_vett( double *v_l, double *v_r, int size);

int main (void) {
    
    double *v_l, *v_r, *new_vect;
    int n; 
    
    
    
    printf ("Inserire la dimensione dei vettori da tastiera \n");
    scanf ("%d", &n);
    
    v_l=malloc(n*sizeof(double));
    v_r=malloc(n*sizeof(double));
    
    riempi_vettore ( v_l, n);
    riempi_vettore ( v_r, n);
    new_vect=new_vett( v_l, v_r, n);
     
    
   
    system("pause");
}

/* FUNZIONI */

void riempi_vettore (double * v, int size) {
    int i;
    
    srand(time(NULL));
    for (i=0; i<size; i++) {
        
v[i]=(rand()%1500+1)/1500.0;

printf (" v[%d]=%lf \n", i, v[i]);

     }
}

/* scrivere funzione che restituisce (return) tre array allocati dinamicamente */

double new_vett( double *v_l, double *v_r, int size) {
       double *x, *y, *alpha;
       int i;
       x=malloc(size*sizeof(double));
       y=malloc(size*sizeof(double));
       alpha=malloc(size*sizeof(double));
       for (i=0; i<size; i++) {
           x[i+1]=x[i]+(v_r[i]+v_l[i])/2*T*cos(alpha[i]);
           y[i+1]=y[i]+(v_r[i]+v_l[i])/2*T*sin(alpha[i]);
           alpha[i+1]=alpha[i]+(v_r[i]-v_l[i])/0.6*T;
           
           }
        printf (" Il valore di x[%d]=%lf\n", i+1, x[i+1]);
        printf (" Il valore di y[%d]=%lf\n", i+1, y[i+1]);
        printf (" Il valore di alpha[%d]=%lf \n", i+1, alpha[i+1]);
        
        
        }
        
           
       

Potreste spiegarmi dove sbaglio e aiutarmi nel correggere gli errori? L'errore segnalato dal compilatore è incompatible types in assignment in new_vect. Grazie.

Alex

[vict85]

Alcuni errori sono il dimenticare (double *) prima dei vari malloc (il mio compilatore è molto restrittivo su queste cose), hai dimenticato il return in new_vec e il fatto che new_vec restituisca un double invece che un double*

A parte queste questioni tu non stai affatto rimandando indietro 3 vettori dentro il main e il main non è pronto a riceverli. Considerando che ne devi far tornare 3 direi che comunque new_vec avrebbe senso non ritornasse nulla o ritornasse valori di controllo e che i vettori fossero caricati come dei puntatori (a puntatori!)

[vict85]

Manca comunque, nel testo, una descrizione dei valori x[0], y[0] e alpha[0]. Senza quelli come fai ad essere sicuro che la funzione funzioni bene? Probabilmente si deve supporre che x[0] = y[0] = 0. Forse anche per l'alpha, ma non è detto.

Ho notato inoltre che, dato che lavori con i+1 dovresti far finire il ciclo con i=size - 2 e quindi imporre i

Cita

Segnala

[bad.alex]

Grazie Vict. E' vero, ho dimenticato (superficialità) prima della malloc il (double*)!
Per quanto riguarda la funzione new_vett io non ho capito quali debbano essere i parametri e come procedere alla restituzione dei vettori ( nonostante mi abbia dato le indicazioni, non ho capito ).

Ricopio il codice con la sola correzione per la malloc:

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <math.h>

#define T 0.01

/* Dichiarazione funzioni */

void riempi_vettore ( double *, int );
double new_vett( double *v_l, double *v_r, int size);

int main (void) {
    
    double *v_l, *v_r, *new_vect;
    int n; 
    
    
    
    printf ("Inserire la dimensione dei vettori da tastiera \n");
    scanf ("%d", &n);
    
    v_l= (double*)malloc(n*sizeof(double));
    v_r= (double*)malloc(n*sizeof(double));
    
    riempi_vettore ( v_l, n);
    riempi_vettore ( v_r, n);
    new_vect=new_vett( v_l, v_r, n);
     
    
   
    system("pause");
}

/* FUNZIONI */

void riempi_vettore (double * v, int size) {
    int i;
    
    srand(time(NULL));
    for (i=0; i<size; i++) {
        
v[i]=(rand()%1500+1)/1500.0;

printf (" v[%d]=%lf \n", i, v[i]);

     }
}

/* scrivere funzione che restituisce (return) tre array allocati dinamicamente */

double new_vett( double *v_l, double *v_r, int size) {
       double *x, *y, *alpha;
       int i;
       x=malloc(size*sizeof(double));
       y=malloc(size*sizeof(double));
       alpha=malloc(size*sizeof(double));
       for (i=0; i<size-1; i++) {
           x[i+1]=x[i]+(v_r[i]+v_l[i])/2*T*cos(alpha[i]);
           y[i+1]=y[i]+(v_r[i]+v_l[i])/2*T*sin(alpha[i]);
           alpha[i+1]=alpha[i]+(v_r[i]-v_l[i])/0.6*T;
           
           }
        printf (" Il valore di x[%d]=%lf\n", i+1, x[i+1]);
        printf (" Il valore di y[%d]=%lf\n", i+1, y[i+1]);
        printf (" Il valore di alpha[%d]=%lf \n", i+1, alpha[i+1]);
        
        
        }
        
           
       

[vict85]

intendo dire che devi fare una funzione del tipo:

void function(double *vec1, double *(*x), double *(*y), double *(*alpha), int size)
{
    \*
    *    eventualmente un po' di codice
    */

    (*x) = (double*) malloc(...);
    (*y) = (double*) malloc(...);
    (*alpha) = (double*) malloc(...);

     \*
     *    il codice
     */
}

Non è una scelta “ottimale” nel senso che nasconde la creazione di memoria dentro una funzione. Le parentesi sono state aggiunte per farti capire che ho mandato un puntatore di puntatore. Tieni conto che un puntatore è una variabile a tutti gli affetti che memorizza l'indirizzo ‘numerico’ di un'altra variabile. In altri termini passare per puntatore equivale a passare ‘per valore’ un puntatore. Non so se mi sono spiegato.

[apatriarca]

L'alternativa all'uso di puntatori di puntatori esiste anche se per ragioni a me sconosciute non è particolarmente usato in C. Probabilmente non si vuole dichiarare una struttura per usarla una sola volta o forse ha a che fare con qualche convenzione. In ogni caso puoi anche fare come segue:

typedef struct Result Result;
struct Result {
    double *x, *y, *alpha;
};

Result function(double *v_l, double *v_r, int size)
{
    Result result;
    result.x = (double*) malloc(/*...*/);
    result.y = (double*) malloc(/*...*/);
    result.z = (double*) malloc(/*...*/);

    /* ... */

    return result;
}

[bad.alex]

RIngrazio entrambi. Per apatriarca: sicuramente, il ricorrere ad una struttura avrebbe facilitato parecchio.
Ma per questioni di tempo il professore non è riuscito ad inserirla nel programma.
Per vict: ok sul puntatore di puntatore ( anche se effettivamente risulta essere un pò "scomodo") ma nel momento della restituzione dei tre vettori nel main, come faccio? Inoltre, volevo chiederti una cosa: quando faccio partire il ciclo for ( all'interno della funzione), come faccio a riempire i vettori, essendo puntatori di puntatori?
Ti riporto il codice ( ma ciò che interessa è la definizione della funzione):

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <math.h>
#define T 0.01

/* Dichiarazione funzioni */

void riempi_vettore ( double *, int );
double new_function(double *vec1, double *(*x), double *(*y), double *(*alpha), int size);

int main (void) {
    
    double *v_l, *v_r, *new_vect;
    int n; 
    
    
    
    printf ("Inserire la dimensione dei vettori da tastiera \n");
    scanf ("%d", &n);
    
    v_l=malloc(n*sizeof(double));
    v_r=malloc(n*sizeof(double));
    
    riempi_vettore ( v_l, n);
    riempi_vettore ( v_r, n);
    new_vect=new_vett( v_l, v_r, n);
     
    
   
    system("pause");
}

/* FUNZIONI */

void riempi_vettore (double * v, int size) {
    int i;
    
    srand(time(NULL));
    for (i=0; i<size; i++) {
        
v[i]=(rand()%1500+1)/1500.0;

printf (" v[%d]=%lf \n", i, v[i]);

     }
}

/* scrivere funzione che restituisce (return) tre array allocati dinamicamente */

double new_function(double *vec1, double *(*x), double *(*y), double *(*alpha), int size)
{
    int i; 
    
/* Alloco dinamicamente i tre vettori */

    (*x) = (double*) malloc(size*sizeof(double));
    (*y) = (double*) malloc(size*sizeof(double));
    (*alpha) = (double*) malloc(size*sizeof(double));

for (i=0; i<size; i++) {
     
     *    il codice
     */
}

[claudio862]

"vict85":Alcuni errori sono il dimenticare (double *) prima dei vari malloc (il mio compilatore è molto restrittivo su queste cose)

Questo non è un errore in C, hai un compilatore troppo restrittivo! In realtà so che stai compilando con un compilatore C++, un linguaggio in cui invece è proprio un errore . Però ci sono buone ragioni per non farlo in C.

"bad.alex":ok sul puntatore di puntatore ( anche se effettivamente risulta essere un pò "scomodo") ma nel momento della restituzione dei tre vettori nel main, come faccio?

Non devi restituire niente, dentro la tua funzione tu stai già lavorando sui vettori del main. Dal main tu hai passato dei puntatori a "qualcosa". Qualunque operazione farai su "qualcosa", sarà visibile anche nel main. In questo caso "qualcosa" = vettore. In altri casi, "qualcosa" = intero (e così via).

"bad.alex":Inoltre, volevo chiederti una cosa: quando faccio partire il ciclo for ( all'interno della funzione), come faccio a riempire i vettori, essendo puntatori di puntatori?

Se a è un puntatore a puntatore, *a è un puntatore. Quindi per riempire i vettori usi (*a)[0], (*a)[1], (*a)...

...

(*x) = (double*) malloc(size*sizeof(double));
(*y) = (double*) malloc(size*sizeof(double));
(*alpha) = (double*) malloc(size*sizeof(double));

for (i=0; i<size; i++) {
    (*x)[i] = ...
    (*y)[i] = ...
    (*alpha)[i] = ...
}

[apatriarca]

@claudio86: di fatto le buone ragioni per non farlo nel C sono in realtà state eliminate con l'avvento del C99 in cui la dichiarazione implicita delle funzioni è stata eliminata. Ma è certamente inutile.. e richiede la scrittura di più codice.

[ot]La dichiarazione implicita di funzioni, insieme alla dichiarazione implicita di variabili in fortran credo che sia tra le funzionalità che abbiano introdotto più problemi che vantaggi nella storia dei linguaggi di programmazione. Probabilmente anche la possibilità di avere un puntatore a NULL è abbastanza alto in questa classifica, lo stesso Hoare (che li ha inventati) l'ha chiamato l' "errore da un miliardo di dollari".[/ot]

[vict85]

"claudio86":Questo non è un errore in C, hai un compilatore troppo restrittivo! In realtà so che stai compilando con un compilatore C++, un linguaggio in cui invece è proprio un errore . Però ci sono buone ragioni per non farlo in C.

Possibile. Sinceramente non ho controllato. Ho un paio di progetti su codeblocks che uso per controllare i vari codici di matematicamente e probabilmente ho usato uno settato sul c++, ma ogni tanto li resetto completamente quindi potrebbe anche non essere. Tanto non ho ancora visto usare un C che usasse uno standard successivo all'89... In ogni caso potrei anche aver messo pedantic errors.
Detto questo penso che tanto valga scriverlo anche soltanto per far mente locale su cosa si stia allocando.

[bad.alex]

Scrivendo il codice all'interno della mia funzione, mi sono accorto che non so come il tutto venga scritto nel main al momento della chiamata a funzione. Essendo puntatori di puntatori, quando chiamo la funzione, quali parametri risultano?

[vict85]

"bad.alex":Scrivendo il codice all'interno della mia funzione, mi sono accorto che non so come il tutto venga scritto nel main al momento della chiamata a funzione. Essendo puntatori di puntatori, quando chiamo la funzione, quali parametri risultano?

Se x è un puntatore allora devi mandare &x cioè l'indirizzo della variabile/puntatore x.

[bad.alex]

Grazie Vict. Allora, essendo puntatore di puntatore, quando effettuo chiamata a funzione devo considerare *x?

[bad.alex]

Ho scritto nuovamente il codice ( non ho pace!):

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <math.h>

#define T 0.01

/* Dichiarazione funzioni */

void riempi_vettore ( double *, int );
double rest_array ( double *, double *, int );


int main (void) {
    
    double *v_l, *v_r;
    int n; 
    
    
    
    printf ("Inserire la dimensione dei vettori da tastiera \n");
    scanf ("%d", &n);
    
    v_l=malloc(n*sizeof(double));
    v_r=malloc(n*sizeof(double));
    
    riempi_vettore ( v_l, n);
    riempi_vettore ( v_r, n);
    
    rest_array (v_l, v_r, n);
     
     
     
     
    system("pause");
}

/* FUNZIONI */

void riempi_vettore (double * v, int size) {
    int i;
    
    srand(time(NULL));
    for (i=0; i<size; i++) {
        
v[i]=(rand()%1500+1)/1500.0;

printf (" v[%d]=%lf \n", i, v[i]);

     }
}

/* Scrivo funzione che restituisce tre nuovi array */

double rest_array ( double *v1, double *v2, int size) {
       int i,j,k;
       double *xx, *yy, *aalpha;
       
/* Alloco dinamicamente i tre vettori */
       
xx=(double*)malloc(size*sizeof(double));
yy=(double*)malloc(size*sizeof(double));
aalpha=(double*)malloc(size*sizeof(double));

/* Riempio i vettori */


for (i=0; i<size; i++) {
    xx[i+1]=xx[i]+ ((v1[i]+v2[i])/2)*0.01*cos(aalpha[i]);
    
    printf (" x[%d]=%lf \n", i+1, xx[i+1]);
}

for (j=0; j<size; j++) {
     yy[j+1]=yy[j]+ ((v1[j]+v2[j])/2)*0.01*sin(aalpha[j]);
    
    printf (" y[%d]=%lf \n", j+1, yy[j+1]);
}

for(k=0; k<size; k++) {
         
aalpha[k+1]=aalpha[k]+ ((v1[k]-v2[k])/0.06)*0.01;
    
    printf (" alpha[%d]=%lf \n", k+1, aalpha[k+1]);
}

}

/* Funzione lunghezza della traiettoria percorsa */

Sono arrivato al punto di dover calcolare la lunghezza della traiettoria e il numero di attraversamento per l'asse x. Ma Avrei un problema nell'individuare i parametri delle rispettive funzioni. Potreste aiutarmi? (piccola nota: il programma restituisce valori -credo-corretti. Però, mandandolo in esecuzione la schermata si chiude dopo qualche secondo. Dov'è l'errore?)

[vict85]

Siccome sembra che tu non abbia colto i miei suggerimenti penso sia venuta l'ora di farti vedere direttamente come si fa, ma devi implementare queste cose negli altri codici simili. Se hai domande chiedi (i const li puoi ignorare e i size_t sono delle sorte di unsigned int).

Ho voluto fare alcune cose per mostrarti che il C, nei nuovi standard, non le richiede: definire le variabili all'inizio della funzione e specialmente mettere malloc.h (che non è una libreria dello standard). Se il tuo compilatore è rimasto agli inizi degli anni 90 allora sposta tu le variabili all'inizio, non dovrebbe essere difficile. Inoltre ho volutamente tolto i printf da dentro le funzioni che fanno i calcoli.

Ho inizializzato x[0], y[0] e alpha[0] tutti a 0. Se il prof vuole cose diverse doveva scriverlo.

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <math.h>

#define T 0.001


void riempi_vettore(double * const, size_t const);

void visualizza_vettore(double const * const, size_t const);

void rest_array( double const * const, double const * const,
                 double ** const, double ** const, double ** const,
                 size_t const );


int main(void)
{
    srand(time(NULL));
    size_t n;
    fputs("Inserire la dimensione dei vettori da tastiera \n", stdout);
    scanf ("%u", &n);

    double *v_l = (double *) malloc(n * sizeof(double));
    double *v_r = (double *) malloc(n * sizeof(double));

    riempi_vettore ( v_l, n);
    printf("Il vettore v_l, di lunghezza %u, e' il seguente: ", n);
    visualizza_vettore(v_l, n);

    riempi_vettore ( v_r, n);
    printf("Il vettore v_r, di lunghezza %u, e' il seguente: ", n);
    visualizza_vettore(v_r, n);

    double *x = NULL;
    double *y = NULL;
    double *alpha = NULL;

    rest_array(v_l, v_r, &x, &y, &alpha, n);
    printf("Il vettore x, di lunghezza %u, e' il seguente: ", n);
    visualizza_vettore(x, n);
    printf("Il vettore y, di lunghezza %u, e' il seguente: ", n);
    visualizza_vettore(y, n);
    printf("Il vettore alpha, di lunghezza %u, e' il seguente: ", n);
    visualizza_vettore(alpha, n);

    /* AGGIUNGERE LE FUNZIONI CHE CALCOLANO LUNGHEZZA E      *
     * IL NUMERO DI VOLTE IN CUI VIENE ATTRAVERSATO L'ASSE X */

    free(v_l);
    free(v_r);
    free(x);
    free(y);
    free(alpha);

    system("pause");
}

/* FUNZIONI */

void riempi_vettore(double * const v, size_t dim)
{
    for (size_t i = 0; i != dim; ++i)
        v[i] = (rand()%1500+1)/1500.0;
}

void visualizza_vettore(double const * const v, size_t const dim)
{
    fputs("[",stdout);
    for(size_t i = 0; i != dim-1; ++i)
        printf("%g, ", v[i]);
    printf("%g", v[dim-1]);
    fputs(" ]\n",stdout);
}

void rest_array( double const * const vl, double const * const vr,
                 double ** const xp, double ** const yp, double ** const ap,
                 size_t const dim)
{
    (*xp) = (double*) malloc(dim * sizeof(double));
    (*yp) = (double*) malloc(dim * sizeof(double));
    (*ap) = (double*) malloc(dim * sizeof(double));

    (*xp)[0] = 0;
    (*yp)[0] = 0;
    (*ap)[0] = 0;

    for(size_t i = 1; i != dim; ++i)
    {
        double const temp = (vl[i-1] + vr[i-1]) * 0.5 * (T);
        double const al_old = (*ap)[i-1];
        double const temp2 = (vl[i-1] - vr[i-1]) * (T);

        (*xp)[i] = temp * cos( al_old );
        (*yp)[i] = temp * sin( al_old );
        (*ap)[i] = al_old + temp2/0.6;
    }
}

[bad.alex]

ti ringrazio vict. si, ho avuto qualche problema nello svolgimento di questo esercizio ( a dire il vero non solo in questo...) e ci sono punti, come la definizione delle funzioni e dei parametri, che mi risultano difficili.
Nel tuo codice qualcosa non mi e' chiara: come mai scrivi

for(size_t i = 1; i != dim; ++i)
    {
        double const temp = (vl[i-1] + vr[i-1]) * 0.5 * (T);
        double const al_old = (*ap)[i-1];
        double const temp2 = (vl[i-1] - vr[i-1]) * (T);

        (*xp)[i] = temp * cos( al_old );
        (*yp)[i] = temp * sin( al_old );
        (*ap)[i] = al_old + temp2/0.6;
    }
}

separando la formula fornita dal problema ?

[vict85]

Quello è solo una scelta stilistica. Di fatto mi evita di riscrivere le cose.

[bad.alex]

quindi per trovare il valore io posso scrivere direttamente la formula data nel testo dell'esercizio?

[vict85]

"bad.alex":quindi per trovare il valore io posso scrivere direttamente la formula data nel testo dell'esercizio?

Certo, in ogni caso penso sia meglio se fai un solo for.

[bad.alex]

Allora, ho provato a riscriverlo tenendo conto delle correzioni:

#include <stdio.h>
#include <stdlib.h>
#include <malloc.h>
#include <time.h>
#include <math.h>

#define T 0.001

/* Dichiarazione funzioni */

void riempi_vettore ( double *, int );
void stampa_vettore ( double *, int ); 
void restituisci_vettore(double *v1, double *v2, double **xx, double **yy, double **aalpha, int size);

int main (void) {
    
    double *v_l, *v_r, *x, *y, *alpha;
    int n; 
    
    
    
    printf ("Inserire la dimensione dei vettori da tastiera \n");
    scanf ("%d", &n);
    
    v_l=malloc(n*sizeof(double));
    v_r=malloc(n*sizeof(double));
    
    riempi_vettore ( v_l, n);
    printf ("Il vettore v_l, di lunghezza %d, e' il seguente:" ,n);
    stampa_vettore (v_l, n);
    
    
    riempi_vettore ( v_r, n);
    printf("Il vettore v_r, di lunghezza %d, e' il seguente:", n);
    stampa_vettore(v_r, n);

/* Inizializzo i tre vettori a 0 */

    x[0]=0;
    y[0]=0;
    alpha[0]=0;
    restituisci_vettore(v_l, v_r, &x, &y, &alpha, n);
    
 printf("Il vettore x, di lunghezza %d, e' il seguente: ", n);
    stampa_vettore(x, n);
    printf("Il vettore y, di lunghezza %d, e' il seguente: ", n);
    stampa_vettore(y, n);
    printf("Il vettore alpha, di lunghezza %d, e' il seguente: ", n);
    stampa_vettore(alpha, n);

    
    
    free(v_l);
    free(v_r);
    free(x);
    free(y);
    free(alpha);

    system("pause");
}


/* FUNZIONI */

void riempi_vettore (double * v, int size) {
    int i;
    
    srand(time(NULL));
    for (i=0; i<size; i++) {
        
v[i]=(rand()%1500+1)/1500.0;

     }
}

void stampa_vettore (double *v, int size) {
     int i;
     for(i=0; i<size; i++) {
              printf (" Il vettore e' v[%d]=%lf \n", i, v[i]);
              }
     }
/*  funzione che restituisce tre array allocati dinamicamente */

void restituisci_vettore(double *v1, double *v2, double **xx, double **yy, double **aalpha, int size)
{
    int i; 
    
/* Alloco dinamicamente i tre vettori */

    (*xx) = (double*) malloc(size*sizeof(double));
    (*yy) = (double*) malloc(size*sizeof(double));
    (*aalpha) = (double*) malloc(size*sizeof(double));

(*xx)[0]=0;
(*yy)[0]=0;
(*aalpha)[0]=0;

for (i=0; i<size; i++) {
     
     (*xx)[i+1]= (*xx)[i]+ (v1[i]+v2[i])/2*T*cos((*aalpha)[i]);
     (*yy)[i+1]= (*yy)[i]+ (v1[i]+v2[i])/2*T*sin((*aalpha)[i]);
     (*aalpha)[i+1]= (*aalpha)[i]+(v1[i]-v2[i])/0.6*T;
     
                }
           }

Nessun errore al momento della compilazione ma quando mando in esecuzione vengono visualizzati soltanto i vettori v_l e v_r. Dopodichè mi si chiude improvvisamente la finestra.

[vict85]

Ok, sono due piccoli errori.

Cancella queste tre righe (i tre array non sono ancora allocati)

x[0]=0;
y[0]=0;
alpha[0]=0;

In restituisci vettore devi scrivere i perché nel ciclo lavori con i+1.