[C] Prodotto tra matrici

[bad.alex]

Si consideri una matrice di n righe, con n inserito da tastiera, e 3 colonne. Ogni riga rappresenta le tre coordinate (x,y,z) di un punto nello spazio.
Si allochi dinamicamente la matrice sulla base del numero di righe inserito da tastiera (fatto).
Si riempia la matrice con valori casuali scelti nei seguenti intervalli:

coordinata x -> [-1,2]
coordinata y -> [0,10]
coordinata z -> [-4,1]

(fatto).
Stampare i valori generati. ( fatto)
Effettuare la rotazione, lungo l'asse x, di ogni punto di un angolo a, inserito da tastiera. La rotazione si ottiene tramite prodotto matriciale:

$((x'),(y'),(z')) = ((1,0,0),(0, cos\alpha, -sin\alpha),(0, sin\alpha, cos\alpha))*((x),(y),(z))$

Sono in difficoltà nel calcolarmi il prodotto tra le due matrici.

Il codice scritto sinora e':

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


double radianti (double angle);

int main (void) {
   int n;
   double *matrice, angle, rad;
   double mat_ang[3][3]={{1,0,0},{0, cos(angle),-sin(angle)},{0,sin(angle),cos(angle)}};
   double *mat_rot;
   int i,j,k;

   printf("Inserire il numero di righe \n");
   scanf("%d", &n);


   /* Alloco dinamicamente la matrice */
   matrice = (double *)malloc(n*3*sizeof(double*));

   if(matrice == NULL)
   {
      printf("Memoria insufficiente\n");
                       }

//Riempio la matrice
   for( i = 0; i < n; i++)
   {

matrice[i]=(rand()*3)/RAND_MAX -1.0;
printf("mat_x=%lf \t \n", matrice[i]);
matrice[i+1]=(rand()*10)/RAND_MAX;
printf("mat_y=%lf \t \n", matrice[i+1]);
matrice[i+2]=(rand()*6)/RAND_MAX-4.0;
printf("mat_z=%lf \t \n", matrice[i+2]);

}


printf (" Inserisci da tastiera il valore dell'angolo in gradi \n");
scanf ("%lf", &angle);

rad=radianti(angle);
printf ( "Il valore dell'angolo in radianti e' %lf \n", rad); 


/* Riempio matrice */

/* 00  01  02
   10  11  12
   20  21  22  */
   
   

/* Effettuo rotazione attorno all'asse x */

/* La rotazione e' un prodotto matriciale */

/* Alloco memoria per la matrice prodotto */

mat_rot = (double*)malloc(3*1*sizeof(double));



            

    system("pause");
}


double radianti (double angle) {
       return ( (angle*3.14)/180);
       }

Vi ringrazio per l'aiuto

[vict85]

Vorrei farti notare che anche se scrivi

double mat_ang[3][3]={{1,0,0},{0, cos(angle),-sin(angle)},{0,sin(angle),cos(angle)}};

non è che mat_ang si ‘aggiorna’ ogni volta che cambi angle. Ogni volta che assegni qualcosa tu assegni il valore che quel qualcosa ha in quel momento, non nei tempi futuri (almeno nel c). Quindi quando da un valore ad angle devi ridefinire mat_ang, non prima.

Inoltre dovresti muoverti di 3 passi alla volta nel ciclo for (immagino comunque che lui volesse una matrice bidimensionale anche se assurdo).

Perché la matrice mar_rot la allochi dinamicamente? Conosci tutte le dimensioni in anticipo. Tra l'altro non ho capito a cosa ti serva...

Cosa c'é di difficoltoso nel prodotto di matrici? Si tratta del normale prodotto riga per colonna...

[bad.alex]

Grazie vict. Per quanto riguarda la nota: hai ragione però non so riempire, anche procedendo riga per colonna, la matrice con quei valori Tutti gli esercizi svolti sinora sulle matrici, richiedevano di inserire i singoli elementi della matrice da tastiera. Analogamente per la matrice di rotazione, in cui non so come fare a calcolare il prodotto delle due matrici con questi valori fissati...

Sull'allocazione dinamica: hai perfettamente ragione!
Non ho capito il discorso dei 3 passi nel ciclo for: perchè dovrei muovermi di 3 passi?

[vict85]

a[0][1] = 10 assegna 10 all'elemento della 2 colonna della prima riga.

La storia dei 3 passi è che altrimenti sovrascrivi gli elementi.

[bad.alex]

Quindi, una volta inserito da tastiera il valore dell'angolo, ad ogni elemento della matrice assegno singolarmente i valori?
a[0][0]=1, a[0][1]=0, ... a[1][1]= cos alpha.... ?
E' possibile ricorrere ad un ciclo for per riempirla in questo modo? se si come?
Volevo inoltre chiederti una cosa: vi sono due modi per poter "pensare" una matrice in C: uno e' attraverso i doppi puntatori **, l'altro attraverso un puntatore *.
Quando vado ad allocare dinamicamente la matrice, nel primo caso scrivo

matrice = (tipo **)malloc (dimensionerighe*sizeof(tipo*));
for (i=0; i<dimensionerighe; i++) {
matrice[i]= (tipo*)malloc(dimensionecolonne*sizeof(tipo));
}

Nel secondo caso, una volta considerato tipo *matrice alloco
matrice =(tipo*)malloc(dimensionerighe*dimensionecolonne*sizeof(tipo));
In questo caso, per accedere agli elementi ( supponiamo per stampare e/o leggere per righe) come devo fare?
In caso voglia scrivere una funzione che stampi gli elementi della matrice, devo scrivere void stampa ( tipo *mat, int dimensione righe, int dimensione colonne)?
Potresti farmi vedere un esempio?


Ti ringrazio