[C++][Programma]

[silence1992]

Ciao a tutti(e buone feste :) ),
devo creare scrivere un programma C che faccia le seguenti cose:
-legge un intero n con , una tolleranza , due vettori reali a n componenti
-genera una matrice A(di dimensione nxn) nel modo seguente:
se :
altrimenti
-genera per le seguenti successioni:


(norma infinito)

e si arresta quando o se e stampa gli ultimi vettori calcolati e il numero di iterazioni effettuate

IO l'ho realizzato nel modo seguente, però io risultati vengono sbagliati...
Qualcuno riesce a vedere l'errore che ho commesso? io l'ho riguardato più volte ma non riesco a capire cosa sbaglio...

Codice: Seleziona tutto

//ESERCIZIO n 4
#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include<iostream>
using namespace std;

void controlla_puntatore(float*);
float tolleranza();
float* alloca_vet(int);
float** alloca_mat(int);
int leggi_dimensione();
void leggi_vet(float*,int);
void matrice(float**,int);
float* mat_vet(float**,float*,int);
float norma(float*,int);
float* somma(float*,float*,int);
void stampa(float*,int);
int metodo(float**,float*,float*,int,float);
void vettore_nullo(float*,int);
float* uguaglianza_vettori(float*,int);
float* differenza_vettori(float*,float*,int);


main()
{
   int n; //n=dimensione vettori e matrice (nxn)
   n=leggi_dimensione();
   
   //leggo da tastiera il vettore x0
   float* x0;
   x0=alloca_vet(n);
   leggi_vet(x0,n);
   
   //leggo da testiera il vettore y0
   float* y0;
   y0=alloca_vet(n);
   leggi_vet(y0,n);
   
   //eps=tolleranza
   float eps;
   eps=tolleranza();
   
   //alloco e determino la matrice A
   float** A;
   A=alloca_mat(n);
   matrice(A,n);
   
   //iter=numero d'iterazioni
   int iter;
   iter=metodo(A,x0,y0,n,eps);
   
   //stampa numero d'iterazioni
   cout<<endl;
   cout<<"Il numero d'iterazioni effettuate e':"<< endl << iter << endl ;
   
   //stampa il vettore finale x0
   cout<<"Il vettore finale della successione, calcolata a partire da x0 e' " << endl ;
   stampa(x0,n);
   
   //stampa il vettore finale y0
   cout<<"Il vettore finale della successione, calcolata a partire da y0 e' " << endl ;
   stampa(y0,n);
   
   return 0;

}

//definisco le funzioni

float* differenza_vettori(float* a,float* b,int n)
{
   float* differenza;
   differenza=alloca_vet(n);
   
   for(int i=0;i<n;i++)
   differenza[i]=a[i]-b[i];
   
   return differenza;
}

float *uguaglianza_vettori(float *a, int dim)
{
// Creo un nuovo vettore uguale a quello passato in input
float *uguale;
uguale=alloca_vet(dim);
for(int i=0;i<dim;i++)
uguale[i]=a[i];
return uguale;
}

void vettore_nullo(float* x,int n)
{
   for(int i=0;i<n;i++)
   x[i]=0;
   
   return;
}

void controlla_puntatore(float* p)
{
   if(p!=NULL) return;
   else
   {
      cout<<"Memoria non allocata..." << endl;
      cout<<"Il programma verra' terminato. " << endl;
      exit(1);
   }
   
}

float* alloca_vet(int n)
{
   float* v;
   v=new float[n];
   controlla_puntatore(v);
   return v;
}

float** alloca_mat(int dim)
{
   float** A;
   A=new float*[dim];
   for(int i=0;i<dim;i++)
   {
      A[i]=new float[dim];
      controlla_puntatore(A[i]);
   }
   
   return A;
}

float tolleranza()
{
   float toll;
   cout<<"Inserire la tolleranza concessa:" << endl;
   do
   {
      cout<<"x=";
      cin>>toll;
      if(toll<=0) cout<<" Il valore inserito non e' accettabile...Riprova"<<endl;
   }while(toll<=0);
   
   return toll;
   
}

int leggi_dimensione()
{
   int n;
   cout<<"Inserire la dimensione dei vettori e della matrice:" << endl;
   do
   {
      cout<<"Il valore deve essere 0<n<=10:" <<endl;
      cin>>n;
      cout<<endl;
      if(n<=0||n>10) cout<<"I valori inseriti non rientrano nel range...Riprovare."<<endl;
   }while(n<=0||n>10);
   
   return n;
}

void leggi_vet(float* v,int dim)
{
   cout<<endl;
   cout<<" Inserire le componenti del vettore: " << endl;
   
   for(int i=0;i<dim;i++)
   {
      cout<<"x["<<i+1<<"]=";
      cin>>v[i];
   }
   
   return;
}

void matrice(float** A,int dim)
{
   for(int i=0;i<dim;i++)
        
         for(int j=0;j<dim;j++)
         {
                 if(i==j) A[i][j]=1;
                else A[i][j]=0.1;
           }
    return;
}

float* mat_vet(float** A,float* b,int dim)
{
   float* prod;
   prod=alloca_vet(dim);
   vettore_nullo(prod,dim);
   
   for(int i=0;i<dim;i++)
       for(int j=0;j<dim;j++)
          prod[i]=prod[i]+A[i][j]*b[j];

   return prod;
}


float norma(float* a,int dim)
{
   float vnorma=0;
   
   for(int i=0;i<dim;i++){
      const float modulo=fabs(a[i]);
      if(modulo>vnorma) vnorma=modulo;
   }
   
   return vnorma;

}

float* somma(float* a, float* b, int n)
{
   float* sum;
   sum=alloca_vet(n);
   
   for(int i=0;i<n;i++)
      sum[i]=a[i]+b[i];
   
   return sum;
}

void stampa(float* a,int dim)
{
   for(int i=0;i<dim;i++)
   cout<<a[i]<< endl;
   
   return;
}

int metodo(float** A,float* x0,float* y0,int n,float eps)
{
   const int nmax=100;
   int cont=0;
   
   float err;
   
   float* xold;
   xold=alloca_vet(n);
   xold=uguaglianza_vettori(x0,n);
   
   float* yold;
   yold=alloca_vet(n);
   yold=uguaglianza_vettori(y0,n);
   
   float* yprod;
   yprod=alloca_vet(n);
   
   float* xprod;
   xprod=alloca_vet(n);
   
   do
   {
      xprod=mat_vet(A,xold,n);
      x0=differenza_vettori(xprod,yold,n);
      
      yprod=mat_vet(A,yold,n);
      y0=differenza_vettori(yprod,xold,n);
      
      err=norma(somma(y0,x0,n),n);
      
      xold=uguaglianza_vettori(x0,n);
      yold=uguaglianza_vettori(y0,n);
      
      cont++;
   }while(err>=eps&&cont<nmax);
   
   return cont;
}
             
         
            


[simo85]

Il programma è scritto un po' in C++ e non completamente in C.

Il testo del problema, da come l' hai scritto tu, non è molto chiaro. Per esempio, cos' è ?

Sbaglio o è la dimensione della matrice A ?

Scusa la ignoranza, cosa è la tolleranza eps ?
EDIT:

tolleranza .
http://realtimecollisiondetection.net/blog/?p=89
http://en.wikibooks.org/wiki/Floating_Point/Epsilon

Ciao

[silence1992]

Allora con epsilon intendo soltanto una quantità da richiedere in lettura da tastiera all'utente
e che servirà come criterio d'arresto nel calcolo delle successioni :
infatti calcolo le successioni per e così via finché
o
o

La matrice, come i vettori iniziali di dimensione , ha righe e colonne quindi

[silence1992]

programma C che

-legge un intero n con , una tolleranza , due vettori reali a componenti


-genera una matrice A(di dimensione ) nel modo seguente:

se :

altrimenti


-genera per le seguenti successioni:

1)

2)

3) (norma infinito)


e si arresta quando o se e stampa gli ultimi vettori calcolati e il numerodi iterazioni effettuate

L'ho modificato,effettivamente prima non era molto chiaro

[obiuan]

Ciao,

siccome il post è vecchiotto e il codice abbastanza lungo, serve ancora una mano o lascio stare?

se sì...nel codice postato usi una funzionte alloca_vet che però non è presente...che fa un malloc? la puoi postare?

puoi postare anche l'output che ricevi in console?