Spline *****bicos

[Fekatur]

Salve galera,

 

Estou com um ep complicado pra fazer e estou recebendo uns erros chatos como:

 

expected '=', ',', ';', 'asm' or '_attribute_' before 'for'

Poderiam me dar uma ajuda? Basicamente preciso resolver um sistema linear que resulta em uma matriz tri-diagonal. Estou tentando usar gradiente conjugado para isso.

Obrigado

Segue o código:

 

#include <stdlib.h>


Calculating the Euclidean norm of a vector
double normvec(int n, double *vt){
    int i;
    double res=0.;
    for(i=0; i<n; i++){
        res=res+pow(vt,2);
    }
    res=sqrt(res);
    return res;
}


int main ()
{
    
        int i=0;
        int nlines=1;
        int it=1;  
        int stop=0;
        int k,j,l,ch,itmax;
        double eps1=0.00000001;
    double sum1,sum2,sum3,beta,alpha;
        double**Coef,*I,*x,*fx,*dx,*dxnew,*dxold,*c,*V,*r,*rnew,*rnorm,*pnew,*betha1,*betha2;
        
        //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ CÁLCULO DO SPLINE +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
        
    
    
    FILE *inputfile;
    
    
    inputfile=fopen("entrada.txt","w");
    if(inputfile==NULL){
        printf("File does not exist or it was removed: entrada.txt\n");
        fclose(inputfile);
        exit(FAILURE);
    }
    do{
        ch=fgetc(inputfile);
        if(ch=='\n'){nlines++;}
    }while(ch!=EOF);
    nlines=nlines-1;
    fclose(inputfile);
    
    x=(double *)malloc(nlines*sizeof(double));
    fx=(double *)malloc(nlines * sizeof(double));
    dx=(double *)malloc(nlines * sizeof(double));
    dxnew=(double *)malloc(nlines * sizeof(double));
    dxold=(double *)malloc(nlines * sizeof(double));
    c=(double *)malloc(nlines * sizeof(double));
    V=(double *)malloc( (nlines*nlines) * sizeof(double));
    r=(double *)malloc( (nlines*nlines) * sizeof(double));
    rnew=(double *)malloc( (nlines*nlines) * sizeof(double));
    rnorm=(double *)malloc( (nlines*nlines) * sizeof(double));
    pnew=(double *)malloc( (nlines*nlines) * sizeof(double));
    betha1=(double *)malloc(nlines * sizeof(double));
    betha2=(double *)malloc(nlines * sizeof(double));
    
    inputfile=fopen("entrada.txt","w");
    for(i=0;i<nlines;i++){
        fscanf(inputfile,"%lf %lf",x,fx);
    }
    fclose(inputfile);
    
    for(k=0;k<nlines;k++){
            c=(fx[i+1]-fx)/(x[i+1]-x);//cálculo de f[xi,x(i+1)]
    }
    dx[0]=0;
    dx[nlines-1]=0;
    
    Coef=(double **)malloc((nlines-2) * sizeof(double *));
    for(i=0;i<nlines-2;i++){
        Coef=(double *)malloc( (nlines-2) * sizeof(double));
    }
    
    I=(double *)malloc((nlines-2) * sizeof(double *));
    
    //zerando a matrix
    for(j=0;j<nlines-2;j++){
        for(k=0;k<nlines-2;k++){
                Coef[j][k]=0.;
        }
    }
    k=0;
    for(j=1;j<nlines-2;j++){
        Coef[j][k]=2*(x[j+1]-x[j-1]);
        Coef[j][k+1]=x[j]-x[j-1];
        Coef[j+1][k]=x[j+2]-x[j+1];
        k++;
    }
    l=0;
    
    for(k=0;k<nlines-2;k++){
            I[k]=3*c[k]*(x[k+2]+x[k+1])+3*c[l+k]*(x[k+1]+x[k]);
    }
    
    
    //Rotina para cáculo das derivadas por gradiente conjugado

    for(k=0;k<nlines;k++){
        dxnew[k]=0.0;
    }
    for(i=0;i<nlines;i++){
        for(j=0;j<nlines;j++){
            sum1=sum1+Coef[j]*dxnew[j];
        }
        r=I-sum1;
        sum1=0.0;
        
    }

    while(stop==0){
        printf("it: %d\n",it);
        if(it==1){
            for(i=0;i<(nlines);i++){
                pnew=r;
            }
        }
        else{
            sum1=0.0;
            sum2=0.0;
            for(i=0;i<(nlines);i++){
                sum1=sum1+rnew*rnew;
                sum2=sum2+r*r;
            }
            beta=sum1/sum2;
            for(i=0;i<(nlines);i++){
                pnew=rnew+beta*pnew;
            }
        }
        sum1=0.0;
        sum2=0.0;
        sum3=0.0;
        for(i=0;i<nlines;i++){
            for(j=0;j<nlines;j++){
                sum1=sum1+pnew[j]*Coef[j];
            }
            sum2=sum2+sum1*pnew;
            sum1=0.0;
            sum3=sum3+(rnew*rnew);
            
        }
        alpha=sum3/sum2;
        sum1=0.0;
        sum2=0.0;
        sum3=0.0;
        for(i=0;i<nlines;i++){
            dxnew=dxold+dxold(alpha*pnew);//Qual o vetor relacionado com ??
            dxold=dxnew;
        }
        for(i=0;i<nlines;i++){
            for(j=0;j<(nlines);j++){
                sum1=sum1+Coef[j]*dxnew[j];
            }
            r=rnew;
            rnew=I-sum1;
            sum1=0.0;
            
        }
        rnorm=normvec(nlines,rnew);
        if(rnorm<=eps1 || it>=itmax){
            stop=1;
            if(it==itmax){
                printf("There was no convergence!\n");
                printf("The routine has reached the maximum iteration limit!\n");
                printf("Try to run the routine again or verify if the obtained solution is good!\n");
            }
            else{
                printf("There was convergence!\n");
                printf("The convergence was reached according to the parameters that you have established!\n");
                printf("Verify if the solution is good. Otherwise, try it again!\n");
            }
        }
        
    }
}


        for(j=0;j<nlines;j++)
        {
            betha1[j]=(c[j]-dx[j])/(x[j+1]-x[j]);//c·lculo de (f[xi,x(i+1)-f'(xi))/(x(i+1)-xi)
            betha2[j]=(dx[j+1]-(2*c[j]])+dx[j])/((x[j+1]-x[j])*(x[j+1]-x[j]));//c·lculo de (f'(xi+1)-2f[xi,x(i+1)+f'(xi))/(x(i+1)-xi)â€
        }

        //Rotina para impressâo da funÃâo S

        for(j=0;j<nlines-2;j++)
        {
            printf("[x%d,x%d]\n",j,j+1);
            printf("S = %lf + %lf(x-%lf) + %lf(x-%lf)² + %lf(x-%lf)².(x-%lf)\n\n",fx[j],dx[j],x[j],betha1[j],x[j],betha2[j],x[j],x[j+1]);
        }

[dontpanic]

Normalmente o teu compilador retorna o erro e a linha onde aconteceu o erro.

Esse tipo de erro "expected (alguma-coisa) before (alguma coisa)" geralmente acontece quando a gente esquece um ponto e vírgula ou esquece de fechar o escopo de uma função.

 

É só ir na linha lá onde deu o erro e consertar.