Problema in C

[pupazzetta]

salve..ho un problema in C
ho scritto un programma che mi chiede di inserire la dimensione di una matrice e poi effettua tutta una serie di calcoli e di chiamate a funzione per poi restituirmi un vettore soluzione...sembra funzionare bene perchè ho fatto tutta una serie di printf e mi restituiscono esatamente i risultati sperati...il problema però sorge quando inserisco determinate dimensioni
EX con dim=16 non stampa il vettore ma qst scritta " -1.#IND00000 "
sapreste dirmi cosa significa e se posso risolverlo!??!?
grazie

[Valerio Capraro]

probabilmente c'è un piccolo errore sugli indici e vai a scorrere il vettore o dove
ancora non è cominciato o dove è già finito e quindi ti stampa un indirizzo di
memoria...
prova a vedere bene gli indici..

p.s. a volte capita che tali errori escano fuori solo per determinate dimensioni

[pupazzetta]

ma se gli indici fossero sbagliati non dovrebbe funzionare con una dimensione maggiore invece già con 17 funziona..

[Valerio Capraro]

se vuoi mandami il sorgente

[pupazzetta]

allora ho una libreria "funzioni.h"

/*libreria "funzioni.h"*/

/* File di libreria */
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <time.h>

/* Dichiarazione delle costanti */
#define N 100

/* Definizione di variabili */
typedef double matrice[N][N];
typedef double vet[N];

/* Prototipi delle funzioni della libreria "funzioni.h" */
void GaussNaive (matrice A, vet b, vet x, int dim);
void GaussPivParz (matrice A, vet b, vet x, int dim);
void GaussPivTot (matrice A, vet b, vet x, int dim);
void PivParScalato(matrice A, vet b, vet x, int dim);
void eliminazioneNaive (matrice A, vet b, int dim);
void eliminazionePivParz (matrice A, vet b, int dim);
void eliminazionePivTot (matrice A, vet b, int dim);
void eliminazioneScaling(matrice A, vet b, int dim);
void pivotingParziale(matrice A, vet b, int dim, int k);
void pivotingTotale(matrice A, vet b, int dim, int k);
void Scaling(matrice A, vet b, int dim, int k);
void backSostitution(matrice A, vet b, vet x, int dim);


poi un programma che contiene le funzioni

/* Funzioni per il calcolo della soluzione di un sistema lineare mediamte il metodo del Pivoting Parziale Scalato */

/* File di libreria */
#include "funzioni.h"

/* Corpo della funzione */
void PivParScalato(matrice A, vet b, vet x, int dim)
{
/* Chiamata di funzioni della libreria "funzioni.h" */
eliminazioneScaling(A, b, dim);
backSostitution(A, b, x, dim);
}
/* ------------------------------------------------------------- */

/* Corpo della funzione */
void eliminazioneScaling(matrice A, vet b, int dim)
{
int i,j,k;
double m;

for(k=0; k<dim; k++){
Scaling(A, b, dim, k);
for(i=k+1; i<dim; i++){
m=A[i][k]/A[k][k];

for(j=k; j<dim; j++){
A[i][j]=A[i][j]-(m*A[k][j]);
}
b[i]= b[i]-(m*b[k]);
}

}
for(i=0; i<dim; i++){
for(j=0; j<dim; j++){
printf(".15%lf ", A[i][j]);
if(j==dim-1){
printf("\n");
}
}
}
}
/* ------------------------------------------------------------- */

/* Corpo della funzione */
void Scaling(matrice A, vet b, int dim, int k)
{
double max, pivot, tmp, tmp2;
int i, j, indice;
vet massimi;

for(i=k; i<dim; i++){
max=fabs(A[i][k]);
for(j=k; j<dim; j++) {
if(fabs(A[i][j])>fabs(max)){
max=fabs(A[i][j]);
}
}
massimi[i]=fabs(A[i][k])/max;
printf(" M %lf ",massimi[i]);
if(i==dim-1) printf("\n\n");
}

pivot=A[k][k];
indice=k;
for(i=k; i<dim; i++){
printf(" S %lf ",massimi[i+1]);
if(massimi[i+1]>massimi[i]){
pivot=A[i+1][k];
indice=i+1;
}
}

for(j=0; j<dim; j++){
tmp=A[k][j];
A[k][j]=A[indice][j];
A[indice][j]=tmp;
}
tmp2=b[k];
b[k]=b[indice];
b[indice]=tmp2;
}
/* ------------------------------------------------------------- */

/* Corpo della funzione */
void backSostitution(matrice A, vet b, vet x, int dim)
{
int i, j;
x[dim-1]=b[dim-1]/A[dim-1][dim-1];

for(i=dim-2; i>=0; i--){
for(j=i+1; j<dim; j++){
b[i]=b[i]-A[i][j]*x[j];
}
x[i]=b[i]/A[i][i];
}
}


e un main nel quale viene inserita una funzione che scrive la matrice di Hankle

/*Questo programma esegue l'algoritmo dell'eliminazione di Gauss con pivoting parziale scalato su una matrice quadrata di ordine n*/

/* File di libreria */
#include "funzioni.h"

/* Prototipi delle funzioni */
void ScriviMatrice(matrice A, int dim);
void ScriviTerminiNoti(matrice A, vet b, int dim);

/* Inizio corpo del programma */
main()
{
/* Dichiarazione delle variabili del main */
int i, dim, j;
double t;
matrice A;
vet b, x;
clock_t start, stop;

do{
printf("Inserisci la dimensione della matrice\n");
scanf("%d", &dim);
} while((dim<0)||(dim>N));

start=clock();

/* Chiamata delle funzioni */
ScriviMatrice(A, dim);
ScriviTerminiNoti(A, b, dim);

/* Chiamata di una funzione della libreria "funzioni.h" */
PivParScalato(A, b, x, dim);

printf("Il vettore soluzione e'\n");
for(i=0; i<dim; i++){
printf("%f\n", x[i]);
}

stop=clock();
t=((double) (stop - start))/CLK_TCK;
printf("somma ricorsiva: %g\n\n", t);

system("PAUSE");
return 0;
}
/* Fine corpo del programma */

/* ------------------------------------------------------------- */

/* Corpo della funzione */
void ScriviMatrice(matrice A, int dim)
{
int i, j;
int k;

for(i=0; i<dim; i++){
for(k=i+2-dim; k<=i+1; k++){
if(k>0){
A[i][dim+k-i-2]=pow(2,k);
} else {
A[i][dim+k-i-2]=pow(2,(1./(2-k)));
}
}
}
}
/* ------------------------------------------------------------- */

/* Corpo della funzione */
void ScriviTerminiNoti(matrice A, vet b, int dim)
{
int i, j;

for(i=0; i<dim; i++){
b[i]=0;
for(j=0; j<dim; j++){
b[i]=b[i]+A[i][j];
}
}
}


il vettore dei termini noti viene costruito facendo in modo che il vettore soluzone sia [1,1,1,.....,1] e quello che viene stampato è proprio il vettore soluzione che a causa degli arrotondamenti presenterà degli errori
devo calcolarlo con dim = 4 8 12 16 20 24 28 32 però con 8 e 16 non funziona

[Valerio Capraro]

A[i][dim+k-i-2]=pow(2,(1./(2-k)));

è normale che ci sia quel punto dopo "1"??

hai provato per altre potenze di "2"?

[pupazzetta]

sinceramente io il punto non ce lo avevo messo poi però mi è stato detto che ci voleva e infatti ho fatto stampare la matrice subito dopo averla scritta prima di essere modificata ed è proprio la matrice che cercavo quindi l'errore non è lì...ho chiesto anke in un altro forum e mi è stato detto che potrebbe essere possibile che nel fare le divisioni con certe dimensioni vengono valori troppo piccoli che il computer non può leggere però siccome è una tesina mi sembra strano non esista soluzione, visto che lui ci ha chiesto di stampargli i vettori soluzione con tutte le dimensioni che ti ho detto prima

[lorven]

Ho eseguito il programma con Dev-C++ così com'è (togliendo i commenti e la libreria funzioni.h)
e funziona per ogni dimensione.
Per dim=16 ho in output un vettore di 16 elementi tutti = 1.000000 e somma ricorsiva=0.031

[pupazzetta]

scusa ma come fa a funzionare senza il file funzioni.h???
da dove prende i prototipi di funzione??
...cmq è strano dovrebbe funzionare sempre anke a me a qst punto...

[lorven]

Hai compilato con Dev-C++? Il valore atteso corrisponde?