[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

[bad.alex]

Perfetto! Adesso parte correttamente. Ti ringrazio