Treceți la conținutul principal

tmatrice cpp clasa

/////////////////////////////////////////////////////////////////
//                                                             //
//                         TENPLATE MATRICE                    //
//                                                             //
//               Serban Alexandru-Claudiu Grupa 1067           //
//                                                             //
/////////////////////////////////////////////////////////////////


#include<stdio.h>
#include<conio.h>
#include<malloc.h>
#include<stdlib.h>
#include<iostream.h>
#include<fstream.h>


template <class T>
class Matrice
{
public:
 int m, n;
 T **a;

 Matrice<T>(int,int);
 Matrice<T>();
 Matrice<T>(char*);
 ~Matrice<T>();
 Matrice<T> unu();
 Matrice<T> zero();
 Matrice<T> transpusa();
 Matrice<T> operator+(Matrice<T> b);
 Matrice<T> operator-(Matrice<T> b);
 Matrice<float> operator*(float nr);
 Matrice<T> operator*(Matrice<T> b);
 Matrice<float> operator/(float nr);
 Matrice<float> operator/(Matrice<T> b);
 T * operator[](int);
 Matrice<float> inversa();
 operator double();
 float * sol_sistem(int *);
 void scrie_fis();


 Matrice<T>(Matrice<T> &b)
 {
  m=b.m;
  n=b.n;
  a=(T **)malloc(m*sizeof(T *));
   for(int i=0; i<m; i++)
    a[i]=(T *)malloc(n*sizeof(T));
  for(i=0; i<m; i++)
   for(int j=0; j<n; j++)
    a[i][j]=b.a[i][j];
 }

 
 friend ostream & operator<<(ostream &iesire, Matrice<T> b)
 {
  for(int i=0; i<b.m; i++)
  {
   iesire<<endl;
   for(int j=0; j<b.n; j++)
    iesire<<" "<<b.a[i][j];
  }
  iesire<<endl;
  return iesire;
 }

 
 friend istream & operator>>(istream &intrare, Matrice<T> &b)
 {
  cout<<"\n m="; intrare>>b.m;
  cout<<" n="; intrare>>b.n;
  cout<<"\n";
  for(int i=0; i<b.m; i++)
   for(int j=0; j<b.n; j++)
   {
    cout<<"elem"<<"["<<i<<"]["<<j<<"]= ";
    intrare>>b.a[i][j];
   }
  return intrare;
 }

};


///////////////////////////////////////////////////////////////////////////////////

template<class T> T * Matrice<T>::operator[](int i)
{
 T *v;
 v=a[i];
 return v;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::Matrice<T>(int n1, int n2)
{
 m=n1; n=n2;
 a=(T **)malloc(m*sizeof(T *));
 for(int i=0; i<m; i++)
  a[i]=(T *)malloc(n*sizeof(T));
 for(i=0; i<m; i++)
  for(int j=0; j<n; j++)
   a[i][j]=0;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::Matrice<T>()
{
 printf("\n m="); scanf("%d",&m);
 printf(" n="); scanf("%d",&n);
 a=(T **)malloc(m*sizeof(T *));
 for(int i=0; i<m; i++)
  a[i]=(T *)malloc(n*sizeof(T));
 for(i=0; i<m; i++)
  for(int j=0; j<n; j++)
  {
   //printf(" a[%d][%d]=",i,j);
   //scanf("%T",&a[i][j]);
   cout<<"a["<<i<<"]["<<j<<"]= ";
   cin>>a[i][j];
  }
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::Matrice<T>(char *c)
{
 int nr_elem,i,j;
 FILE *f;
 T aux;
 
 f=fopen(c,"rb");
 fseek(f,0,SEEK_END);
 nr_elem=(ftell(f)-sizeof(int))/sizeof(T);
 fseek(f,0,SEEK_SET);
 fread(&m,sizeof(int),1,f);
 n=nr_elem/m;
 a=(T **)malloc(m*sizeof(T *));
    for(i=0;i<m;i++)
     a[i]=(T *)malloc(m*sizeof(T));
    for(i=0;i<m;i++)
  for(j=0;j<n;j++)
         {
   fread(&aux,sizeof(T),1,f);
    a[i][j]=aux;
         }
   fclose(f);
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> void Matrice<T>::scrie_fis()
{
 FILE *f;
 int i,j;
  
 f=fopen("mat.cla","w+");
 fwrite(&m,sizeof(int),1,f);
 T k;
 for(i=0;i<m;i++)
  for(j=0;j<n;j++)
     {
   k=a[i][j];
      fwrite(&k,sizeof(T),1,f);
  }
 fclose(f);
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::~Matrice<T>()
{
 for(int i=0; i<m; i++)
  free(a[i]);
 free(a);
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::unu()
{
 int i,j;

 if(m!=n)
 {
  cout<<"\n Matricea nu este patratica!";
 }
 else 
 {
  for(i=0; i<m; i++)
   for(j=0; j<n; j++)
    if(i==j) a[i][i]=1;
    else a[i][j]=0;
 }
 return *this;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::zero()
{
 int i,j;
 for(i=0; i<m; i++)
  for(j=0; j<n; j++)
   a[i][j]=0;
 return *this;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::transpusa()
{
 Matrice<T> b(n,m);
 b.m=n;
 b.n=m;
 for(int i=0; i<n; i++)
  for(int j=0; j<m; j++)
   b.a[i][j]=a[j][i];
 return b;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::operator*(Matrice<T> b)
{
 int i,j,k;
 T atemp,btemp,ctemp;
 
 if(n!=b.m)
 {
  cout<<"\n Dimensiunile matricelor sunt incorecte!!";
  cout<<"\n Matricele nu se pot inmulti!!";
  Matrice<T> d(1,0);
  return d;
 }
 else
 {
  Matrice<T> c(m,b.n);
  for(i=0; i<c.m; i++)
   for(j=0; j<c.n; j++)
   {
    ctemp=0;
    for(k=0; k<b.m; k++)
    {
     atemp=a[i][k];
     btemp=b.a[k][j];
     ctemp=ctemp+atemp*btemp;
    }
    c.a[i][j]=ctemp;
   }
  return c;
 }
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::operator*(float nr)
{
 Matrice<float> c(m,n);
 c.m=m;
 c.n=n;
 for(int i=0; i<m; i++)
  for(int j=0; j<n; j++)
   c.a[i][j]=a[i][j]*nr;
 return c;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::operator+(Matrice<T> b)
{
 int i,j;
 if((m!=b.m)||(n!=b.n))
 {
  printf("\n Matricile au dimensiuni diferite!!");
  printf("\n Adunarea nu se poate efectua!!");
  Matrice<T> d(1,0);
  return d;
 }
 else
 {
  Matrice<T> c(m,n);
  c.m=m;
  c.n=n;
  for(i=0; i<m; i++)
   for(j=0; j<n; j++)
    c.a[i][j]=a[i][j]+b.a[i][j];
  return c;
 }
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T> Matrice<T>::operator-(Matrice<T> b)
{
 int i,j;
 if((m!=b.m)||(n!=b.n))
 {
  printf("\n Matricile au dimensiuni diferite!!");
  printf("\n Scaderea nu se poate efectua!");
  Matrice<T> d(1,0);
  return d;
 }
 else
 {
  Matrice<T> c(m,n);
  c.m=m;
  c.n=n;
  for(i=0; i<m; i++)
   for(j=0; j<n; j++)
    c.a[i][j]=a[i][j]-b.a[i][j];
  return c;
 }
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::operator/(float nr)
{
 int i,j;
 Matrice<float> c(m,n);
 c.m=m;
 c.n=n;
 for(i=0; i<m; i++)
  for(j=0; j<n; j++)
   c.a[i][j]=(float)a[i][j]/nr;
 return c;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::operator/(Matrice<T> b)
{
 int i,j,k;
 float atemp,btemp,ctemp;
 if((m!=b.m)||(n!=b.n))
 {
  printf("\n Matricele nu au aceleasi dimensiuni!!");
  printf("\n Impartirea nu se poate efectua!!");
  Matrice<float> d(1,0);
  return d;
 }
 else
 {
  int m_inv=b.inversa().m;
  int n_inv=b.inversa().n;
  Matrice<float> inv(m_inv,n_inv);
  if((inv.m==1)&&(inv.n==0))
  {
   printf("\n Impartirea nu se poate efectua!!");
   Matrice<float> e(1,0);
   return e;
  }
  else
  {
   Matrice<float> c(b.m,b.n);
//   cout<<"\n INV B\n"<<b.inversa();
//   getch();
   for(i=0; i<m; i++)
    for(j=0; j<n; j++)
     inv.a[i][j]=b.inversa().a[i][j];
//   cout<<"\n INV \n"<<inv;
//   getch();
  
   for(i=0; i<m; i++)
   {
    for(j=0; j<n; j++)
    {
     ctemp=0;
     for(k=0; k<n; k++)
     {
      atemp=(float)a[i][k];
      btemp=inv.a[k][j];
      ctemp=ctemp+atemp*btemp;
     }
     c.a[i][j]=ctemp;
//     printf("\n a[%d][%d]=%.3f",i,j,c.a[i][j]);
    }
   }
   return c;
  }
 }
}


///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<float> Matrice<T>::inversa()
{

//cod=1 - exista inversa
//cod=2 - nu exista inversa
 
 float eps, btemp, atemp, amax, mod, c;
 int i,j,k,imax,vb=0,cod=1;

 Matrice<float> b(m,m);
 b.unu();
 Matrice<float> ca(m,m);
 for(i=0; i<m; i++)
  for(j=0; j<m; j++)
   ca.a[i][j]=(float)a[i][j];

 if(m!=n)
 {
  printf("\n Matricea nu este patratica!!");
  cod=2;
 }
 else
 {
  eps=float(0.00001);
  k=0; i=0; vb=0;
  do
  {
   if(k!=n-1)
   {
    amax=ca.a[k][k];
    if(amax<0) amax=-amax;
    imax=k;
    for(i=k+1; i<m; i++)
    {
     if(ca.a[i][k]<0) mod=-ca.a[i][k];
     else mod=ca.a[i][k];
     if(mod>amax)
     {
      amax=mod;
      imax=i;
     }

    }
    if(imax!=k)
     for(j=0; j<n; j++)
     {
      atemp=ca.a[imax][j];
      ca.a[imax][j]=ca.a[k][j];
      ca.a[k][j]=atemp;
      btemp=b.a[imax][j];
      b.a[imax][j]=b.a[k][j];
      b.a[k][j]=btemp;
     }
   }


   if(ca.a[k][k]<0) mod=-ca.a[k][k];
   else mod=ca.a[k][k];
   
   if(mod<=eps)
   {
    cod=2;
    vb=1;
   }
   else
   {
    c=ca.a[k][k];
    for(j=0; j<n; j++)
    {
     ca.a[k][j]=ca.a[k][j]/c;
     b.a[k][j]=b.a[k][j]/c;
    }
    for(i=0; i<n; i++)
     if(i!=k)
     {
      c=-ca.a[i][k];
      for(j=0; j<n; j++)
      {
       ca.a[i][j]=ca.a[i][j]+c*ca.a[k][j];
       b.a[i][j]=b.a[i][j]+c*b.a[k][j];
      }
     }
    
    k=k+1;
    if(k>n-1)
    {
     cod=1;
     vb=1;
    }
   }
  }
  while(vb==0);
 }

 if (cod==2)
 {
  printf("\n Nu exista inversa!");
  Matrice<float> d(1,0);
  return d;
 }
 else return b;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> Matrice<T>::operator double()
{
 float eps;
 double det;
 float amax, atemp, c;
 int i,j,k,imax,vb=0,cod=1;

 if(m!=n)
 {
  printf("\n Matricea nu este patratica!!");
  printf("\n Nu exista determinantul!!");
  return 0xfffffff;
 }
 else
 {
  Matrice<float> ca(m,n);
  for(i=0; i<m; i++)
   for(j=0; j<m; j++)
    ca.a[i][j]=(float)a[i][j];

  eps=float(0.00001);
  k=0; i=0; vb=0; det=1;
  
  do
  {
   if(k!=n-1)
   {
    amax=ca.a[k][k];
    if(amax<0) amax=-amax;
    imax=k;
    for(i=k+1; i<m; i++)
    {
     if(ca.a[i][k]<0) c=-ca.a[i][k];
     else c=ca.a[i][k];
     if(c>amax)
     {
      amax=c;
      imax=i;
     }

    }
    if(imax!=k)
    {
     det=-det;
     for(j=0; j<n; j++)
     {
      atemp=ca.a[imax][j];
      ca.a[imax][j]=ca.a[k][j];
      ca.a[k][j]=atemp;
     }
    }
   }


   if(ca.a[k][k]<0) c=-ca.a[k][k];
   else c=ca.a[k][k];
   
   if(c<=eps)
   {
    cod=2;
    vb=1;
   }
   else
   {
    c=ca.a[k][k];
    det=det*c;
    for(j=0; j<n; j++) ca.a[k][j]=ca.a[k][j]/c;
    for(i=0; i<n; i++)
     if(i!=k)
     {
      c=-ca.a[i][k];
      for(j=0; j<n; j++) ca.a[i][j]=ca.a[i][j]+c*ca.a[k][j];
     }
    
    k=k+1;
    if(k>n-1)
    {
     cod=1;
     vb=1;
    }
   }
  }
  while(vb==0);
 }

 if(cod==2) 
 {
  printf("\n Det se aprox nul!!"); 
  return det=0;
 }
 if(cod==1) return det;
}

///////////////////////////////////////////////////////////////////////////////////

template<class T> float * Matrice<T>::sol_sistem(int * cod)
{

// cod=1: s-a obtinut solutia
// cod=2: solutia nu este unica
// cod=3: matricea nu este patratica

 float eps, atemp, amax, c;
 float *x;
 int i, j, k, imax, vb;
 Matrice<float> a1(m,n+1);
 x=(float *)malloc(m*sizeof(float));
 printf("\n Introduceti termenii liberi:\n");
 for(i=0; i<m; i++)
 {
  //printf(" b[%d]=",i);
  //scanf("%f",&x[i]);
  cout<<" b["<<i<<"]=";
  cin>>x[i];
 }

 eps=float(0.00001);
 
 if(m!=n) *cod=3;
 else
 {
  for(i=0; i<m; i++)
  {
   for(j=0; j<n; j++)
    a1.a[i][j]=(float)a[i][j];
   a1.a[i][n]=x[i];
  }

  k=0; vb=0;

  do
  {
   if(k!=n-1)
   {
    amax=a1.a[k][k];
    if(amax<0) amax=-amax;
    imax=k;
    for(i=k+1; i<m; i++)
    {
     if(a1.a[i][k]<0) c=-a1.a[i][k];
     else c=a1.a[i][k];
     if(c>amax)
     {
      amax=c;
      imax=i;
     }
    }
    if(imax!=k)
    {
     for(j=k; j<n+1; j++)
     {
      atemp=a1.a[imax][j];
      a1.a[imax][j]=a1.a[k][j];
      a1.a[k][j]=atemp;
     }
    }    
   }

   if(a1.a[k][k]<0) c=-a1.a[k][k];
   else c=a1.a[k][k];
   
   if(c<=eps)
   {
    vb=1; 
    *cod=2;
   }
   else
   {
    c=a1.a[k][k];
    for(j=k; j<n+1; j++)
     a1.a[k][j]=a1.a[k][j]/c;
    for(i=0; i<n; i++)
     if(i!=k)
     {
      c=-a1.a[i][k];
      for(j=k; j<n+1; j++)
       a1.a[i][j]=a1.a[i][j]+c*a1.a[k][j];
     }

    k=k+1;
    if(k>n-1)
    {
     for(i=0; i<n; i++)
      x[i]=a1.a[i][n];
     vb=1; *cod=1;
    }
   }
  }
  while(vb==0);
 }
 if(*cod==1) return x;
 if(*cod!=1) return NULL;

}

///////////////////////////////////////////////////////////////////////////////////


void main()
{
 float nr_int, nr_float;
 float *sol_int, *sol_float;
 double deta_int, deta_float;

 ios::sync_with_stdio();

 cout<<"\n--------------------------------------------------------------------------------\n";
 cout<<"                             MATRICE CU ELEMENTE INTREGI\n\n";

 printf("\n Introduceti prima matrice:");
 Matrice<int> a;
 printf("\n Introduceti a doua matrice:");
 Matrice<int> b;


 
 cout<<"\n Elementul a[0][0] din prima matrice este: "<<a[0][0]<<"\n";
 getch();
 
 printf("\n Suma matricelor:\n");
 cout<<a+b;
 getch();


 printf("\n Diferenta matricelor:\n");
 cout<<a-b;
 getch();

 printf("\n Produsul matricelor:\n");
 cout<<a*b;
 getch();

 printf("\n Impartirea matricelor: \n");
 cout<<a/b;
 getch();

 cout<<"\n Introduceti un numar: ";
 cin>>nr_int;
 cout<<"\n Produsul primei matrice cu numarul "<<nr_int<<" este:\n";
 cout<<a*nr_int;
 getch();

 cout<<"\n Rezultatul impartirii primei matrice la numarul "<<nr_int<<" este:\n";
 cout<<a/nr_int;
 getch();

 printf("\n Calculul determinantului primei matrice:\n");
 deta_int=double(a);
 if(deta_int!=0xfffffff) printf("\n Determinantul este: %lf\n",deta_int);
 getch();

 printf("\n\n Transpusa primei matrice:\n");
 cout<<a.transpusa();
 getch();

 printf("\n Inversa primei matrice:\n");
 cout<<a.inversa();
 getch();
 
 printf("\n Calculul solutiilor sistemului dat de prima matrice:\n");
 int cod=1;
 sol_int=a.sol_sistem(&cod);
 
 if(cod==1)
 {
  printf("\n Solutiile sistemului sunt:\n");
  for(int i=0; i<a.m; i++)
  {
   printf("\n x%d=",i+1);
   printf(" %.3f",sol_int[i]);
  }
 }
 if(cod==2) printf("\n Solutia nu este unica!!");
 if(cod==3) printf("\n Matricea nu este patratica!!");
 printf("\n");
 getch();

 printf("\n Scriu matricea a in fisierul mat.cla.\n");
 a.scrie_fis();
 getch();

 printf("\n Citesc matricea c din fisier (constructor din fisier).\n");
 Matrice<int> c("mat.cla");
 getch();
 
 printf("\n Afisez matricea c citita din fisier:\n");
 cout<<c;
 getch();

 system("cls");
 cout<<"\n--------------------------------------------------------------------------------\n";
 cout<<"                             MATRICE CU ELEMENTE REALE\n\n";

 printf("\n Introduceti prima matrice:");
 Matrice<float> a1;
 printf("\n Introduceti a doua matrice:");
 Matrice<float> b1;


 
 cout<<"\n Elementul a[0][0] din prima matrice este: "<<a1[0][0]<<"\n";
 getch();
 
 printf("\n Suma matricelor:\n");
 cout<<a1+b1;
 getch();


 printf("\n Diferenta matricelor:\n");
 cout<<a1-b1;
 getch();

 printf("\n Produsul matricelor:\n");
 cout<<a1*b1;
 getch();

 printf("\n Impartirea matricelor: \n");
 cout<<a1/b1;
 getch();

 cout<<"\n Introduceti un numar: ";
 cin>>nr_float;
 cout<<"\n Produsul primei matrice cu numarul "<<nr_float<<" este:\n";
 cout<<a1*nr_float;
 getch();

 cout<<"\n Rezultatul impartirii primei matrice la numarul "<<nr_float<<" este:\n";
 cout<<a1/nr_float;
 getch();

 printf("\n Calculul determinantului primei matrice:\n");
 deta_float=double(a1);
 if(deta_float!=0xfffffff) printf("\n Determinantul este: %lf\n",deta_float);
 getch();

 printf("\n\n Transpusa primei matrice:\n");
 cout<<a1.transpusa();
 getch();

 printf("\n Inversa primei matrice:\n");
 cout<<a1.inversa();
 getch();
 
 printf("\n Calculul solutiilor sistemului dat de prima matrice:\n");
 cod=1;
 sol_float=a1.sol_sistem(&cod);
 
 if(cod==1)
 {
  printf("\n Solutiile sistemului sunt:\n");
  for(int i=0; i<a1.m; i++)
  {
   printf("\n x%d=",i+1);
   printf(" %.3f",sol_float[i]);
  }
 }
 if(cod==2) printf("\n Solutia nu este unica!!");
 if(cod==3) printf("\n Matricea nu este patratica!!");
 printf("\n");
 getch();

 printf("\n Scriu matricea a in fisierul mat.cla.\n");
 a1.scrie_fis();
 getch();

 printf("\n Citesc matricea c din fisier (constructor din fisier).\n");
 Matrice<float> c1("mat.cla");
 getch();
 
 printf("\n Afisez matricea c citita din fisier:\n");
 cout<<c1;

 getch();
}




Comentarii

Postări populare de pe acest blog

program principal cpp

#include "clasa.h" #include <stdio.h> #include <conio.h> #include <stdlib.h> #include <string.h> #define DELAY 9000000 void delay() { for(long i=0;i<DELAY;i++); } //constructor cu initializare de la tastatura BigInt::BigInt() {char x; signed char t[400]; int i; printf("\nNumarul cu semn "); do s=getche(); while((s!='+')&&(s!='-')); n=0; do {x=getche(); t[n]=x-'0'; n++; } while((x>='0')&&(x<='9')); n--; for(i=0;i<n;i++) nr[i]=t[n-i-1]; } //constructor cu initializare prin parametri BigInt::BigInt(char semn,signed char numar[],int dim) {int i; s=semn; n=dim; for(i=0;i<n;i++) nr[i]=numar[n-i-1]; } //transform un int negativ in pozitiv int BigInt::Pozitiv(int x) {int a,vb; a=0; vb=0; while(vb==0) if((x+a)==0) vb=1; else a=a+1; x=a; return x; } //constructor dintr-un nr int obisnuit BigInt::BigInt(int x) {int i; if(x>=0) s='+'…

NUMERE PRIME ALGORITM C++

// NUMERE PRIME ALGORITM C++//  reediting from scratch //on this page is just the study for a next algoritm for generating the parime nr series like Fibonnaci or ....if possibile

74111121313417374414124343447 if u know the red part you can generate the orange part
1 0 1 111112222 1 1 23

o aplicatie php localitati romania

//APLICATIA SE REFERA LA BAZA DE DATE SIRUTA

//dragtable.js


/* dragtable v1.0 June 26, 2008 Dan Vanderkam, http://danvk.org/dragtable/ http://code.google.com/p/dragtable/ \Bsortabledraggable\B Instructions: - Download this file - Add <script src="dragtable.js"></script> to your HTML. - Add class="draggable" to any table you might like to reorder. - Drag the headers around to reorder them. This is code was based on: - Stuart Langridge's SortTable (kryogenix.org/code/browser/sorttable) - Mike Hall's draggable class (http://www.brainjar.com/dhtml/drag/) - A discussion of permuting table columns on comp.lang.javascript Licensed under the MIT license. */ // Here's the notice from Mike Hall's draggable script: //***************************************************************************** // Do not remove this notice. // // Copyright 2001 by Mike Hall. // See http…