matrix_vector.h

Go to the documentation of this file.

#ifndef MUMECH_MATRIX_VECTOR_H
#define MUMECH_MATRIX_VECTOR_H

#include <stdio.h>
#include <string.h>

namespace mumech {


// ***********************************************************************************************************
// ****************   2D ONLY - START   **********************************************************************
// ***********************************************************************************************************

class vektor
{
 public:
  long p;
  double *v;
  vektor(){ p=0; v=NULL; };
  vektor(long n){ p=n; v=new double[p]; long i; for(i=0;i<p;i++)v[i]=0.0; };
  ~vektor(){ if(v!=NULL){ delete []v;v=NULL; p=0; } };
  void odalokovat(){ if(v!=NULL){ delete []v;v=NULL; p=0; } };
  
  double norma () const;
  
  void vynulovat(){   long i;   for(i=0;i<p;i++)v[i]=0.0;   };
  void rovna_se(vektor &co){   long i;   for(i=0;i<p;i++)v[i]=co.v[i];   };
  void krat(double cislo){   long i;   for(i=0;i<p;i++)v[i]=v[i]*cislo;   };
  void define(long n){ p=n; v=new double[p]; long i; for(i=0;i<p;i++)v[i]=0.0; };
  double& g(long i){return v[i];};
  void print(FILE *soubor){
    long i;
    for(i=0;i<p;i++){
      //fprintf(soubor,"%ld) %4.10f\n",i,v[i]);
                        fprintf(soubor, "%.10f\n", v[i]);
    } 
    fprintf(soubor,"\n"); 
  }
  
  /*int MxV(vektor &vek){
    if(s!=vek.p)return 0;
    matrix zaloha(r,s);
    int u,v,r;
    for(u=0;u<r;u++)for(v=0;v<s;v++)m[u][v]+=g(u,v);
    vynulovat();
    for(u=0;u<r;u++)for(v=0;v<s;v++)for(r=0;r<s;r++)m[u][v]+=zaloha.g(u,r)*vek.v[r];
    return 1; 
    };  */
  int pricist(vektor &co){if(p!=co.p)return 0;long i;for(i=0;i<p;i++)g(i)+=co.g(i);return 1;};
  int odecist(vektor &co){if(p!=co.p)return 0;long i;for(i=0;i<p;i++)g(i)-=co.g(i);return 1;};
        void deleno(long double cislo) { long i;   for (i = 0; i<p; i++)v[i] = v[i] / cislo; };
};

class matice
{
 public:
  int R;
  int S;
  int r;
  int s;
  bool t;
  double *m;
  
        matice(){ R=0; S=0; r=0; s=0; t=false; m=NULL; };
        matice(int radku,int sloupcu){
    int i;
    t=false;
    R=r=radku;S=s=sloupcu;
    m=new double[r*s];
    for(i=0;i<r*s;i++)m[i]=0.0;
  };
  
  void define(int radku,int sloupcu){
        int i;
        t=false;
        R=r=radku;S=s=sloupcu;
        m=new double[r*s];
        for(i=0;i<r*s;i++)m[i]=0.0;
  };
  
  ~matice(){ if(m!=NULL){ delete []m; R=r=0; S=s=0; m=NULL; t=false; } };
  
  void destruct(){ if(m!=NULL){ delete []m; R=r=0; S=s=0; m=NULL; t=false; } };
  double& g(int radek,int sloupec){
    if(t){
      if( radek>=0 && radek<=r && sloupec>=0 && sloupec<=s)return m[sloupec*S+radek]; 
    }else{
      if( radek>=0 && radek<=r && sloupec>=0 && sloupec<=s)return m[radek*S+sloupec];
    }
    printf("\nCHYBA - pokus o pristup mimo oblast matice\n");
    return m[0];
  };
  
  void vynulovat(){int i;for(i=0;i<r*s;i++)m[i]=0.0;};
  void krat(double cislo){int i;for(i=0;i<r*s;i++)m[i]*=cislo;};
  //NAHORU OK
  
  int nasobeni(matice &a, matice &b){
    if(r!=a.r || s!=b.s || a.s!=b.r)return 0;
    int u,v,rr;
    vynulovat();
    for(u=0;u<r;u++)for(v=0;v<s;v++)for(rr=0;rr<a.s;rr++)g(u,v)+=1.0*a.g(u,rr)*b.g(rr,v);
    return 1;
  };
  
  int VxM(vektor &vek){
    if(r!=vek.p)return 0;
                matice zaloha(r,s);
    int u,v,rr;
    for(u=0;u<r;u++)for(v=0;v<s;v++)g(u,v)+=g(u,v);
    vynulovat();
    for(u=0;u<r;u++)for(v=0;v<s;v++)for(rr=0;rr<s;rr++)g(u,v)+=vek.v[rr]*zaloha.g(rr,v);
    return 1; 
  };
  
  //DOLU OK
  void transpose(){
    t=true;
    s=R;
    r=S;
  };
  void untranspose(){
    t=false;
    s=S;
    r=R;
  };
  
  int rovna_se (const matice &src) {
    if(r!=src.r || s!=src.s)
      return 0;
    
    memcpy (this->m, src.m, r*s * sizeof(double));
    
    return 1;
  }
  int pricist(matice &co){if(r!=co.r || s!=co.s)return 0;int i,j;for(i=0;i<r;i++)for(j=0;j<s;j++)g(i,j)+=co.g(i,j);return 1;}
  int odecist(matice &co){if(r!=co.r || s!=co.s)return 0;int i,j;for(i=0;i<r;i++)for(j=0;j<s;j++)g(i,j)-=co.g(i,j);return 1;}
  void print(FILE *soubor){
    int u,v;
    for(u=0;u<r;u++){
      for(v=0;v<s;v++)fprintf(soubor,"%.10lf ",g(u,v));
      fprintf(soubor,"\n");
    } 
    fprintf(soubor,"\n"); 
  };
  double Determinant_3x3(){
    if(r!=3 || s!=3)return 0;
    return g(0,0)*g(1,1)*g(2,2)-g(2,0)*g(1,1)*g(0,2)+g(0,1)*g(1,2)*g(2,0)+g(1,0)*g(2,1)*g(0,2)-g(0,1)*g(1,0)*g(2,2)-g(0,0)*g(2,1)*g(1,2);
  };
  double Determinant_3x3_doplnek(int i,int j){
    if(r==3 && s==3){
      int r1,r2,s1,s2;
      if(r!=3 || s!=3)return 0;
      if(i==0){r1=1;r2=2;}
      if(i==1){r1=0;r2=2;}
      if(i==2){r1=0;r2=1;}
      if(j==0){s1=1;s2=2;}
      if(j==1){s1=0;s2=2;}
      if(j==2){s1=0;s2=1;}
      return g(r1,s1)*g(r2,s2)-g(r1,s2)*g(r2,s1);
    }else{
      printf("\nCHYBA - spatny rozmer matice pro pouziti funkce Determinant_3x3_doplnek\n");
      return 0.0;
    }
  };
  
  void inverze_3x3 (matice &d);
};

void enter();
void e(int i);

int MaticexVektor(vektor &res, matice &mat,vektor &vek);
int RozdilVektoru(vektor &a,vektor &b,vektor &c);
void PrintVektor(vektor &vekt);
void PrintMatrix(matice &mat,FILE *&soubor);
void rotate_vector (vektor &V, double angle);
void change_radky(vektor &a, vektor &b);
void gaussovaEliminace(matice &mat, vektor &right);

// ***********************************************************************************************************
// ****************   2D ONLY -  END    **********************************************************************
// ***********************************************************************************************************

} // namespace mumech

#endif // MUMECH_MATRIX_VECTOR_H