/*******************************************************************************
   Moduli:        matriisi.cpp
   Tarkoitus:     Neli”matriiseja k„sittelev„ matriisiluokka cMatrix.
                  N„it„ k„ytett„ess„ tarvitaan my”s vektoriluokka cVec
                  (vektorit.h ja vektorit.cpp). Matriisin koko on m„„ritelty
                  vektorit.h:ssa. Luokalla on yksi yhteinen vektori,
                  joka palautetaan, jos on viitattu v„„r„„n riviin tai
                  sarakkeeseen.
   Projekti:      Winlin, Cum laude approbatur -harjoitustyö
   Tekijät:       Virpi Kivinen & Tiina Mäkinen
   Tehty:         1.1.96
   Muutettu       14.7.96
   Mitä muutettu: + 14.7. metodi ei_litussa, jolla tarkistetaan onko matriisin
                    determinantti nolla.
   Puutteet:

  Matriisiluokan metodit:
   - const cMatrix &cMatrix::kierto(double angle, int axel=1)
       Tekee kiertomatriisin x-, y- tai z-akselin suhteen
       kiertokulmalla angle (asteita); jos axel=1, niin kierret„„n x-akselin
       suhteen; jos 2, niin y_akselin ja jos 3, niin z-akselin suhteen.
       Palauttaa kiertomatriisin.
   - int cMatrix::tee_muunnos
     (const int xstep,const double dx,const double dy, double factor = 1.0)
       Muuttaa origon keskelle ikkunaa, factor on pikselin kerroin y-suuntaan.
   - const cMatrix &cMatrix::siirto(const double a=0.0,const double b=0.0,const double c=0.0)
       Tekee siirtomatriisin, jossa a on x-siirto, b y- ja c z-siirto.
       Palauttaa siirtomatriisin.
   - const cMatrix &cMatrix::vaanto(const double a, int b=1)
       Tekee xy-tason v„„nt”matriisin. Jos b=1, niin v„„nnet„„n x:n suuntaan.
       Jos b=2, niin v„„nnet„„n y:n suuntaan ja jos c=3, niin z:n suuntaan.
       Palauttaa v„„nt”matriisin.
   - const cMatrix &cMatrix::skaalaus(const double a=1.0,const double b=1.0,const double c=1.0)
       Tekee skaalausmatriisin, jossa a on x-skaalaus, b y- ja c z-skaalaus.
       Palauttaa skaalausmatriisin.
   - cVec &cMatrix::operator[](int i)
       Palauttaa matriisin i:nnen rivin (0,1...). Jos viittaus on v„„r„, niin
       palauttaa luvattoman.
   - const cVec &cMatrix::operator[](int i) const
   - cMatrix &cMatrix::operator=(const cMatrix &M)
       Sijoittaa M:n matriisiin ja palauttaa t„m„n.
   - cMatrix cMatrix::operator=(const double i)
       Tekee diagonaalimatriisin i:ll„.
   - cVec cMatrix :: ref(const int i) const
       Palauttaa matriisin sarakkeen. Jos viittaus on v„„r„, niin palauttaa
       luvattoman.
   - cMatrix &cMatrix::operator*=(const cMatrix &M)
       Matriisi=matriisi*M.
       Palauttaa n„in saadun matriisin.
   - cMatrix operator*(const cMatrix &M1,const cMatrix &M2)
       M1*M2 ja n„in saatu tulos palautetaan.
   - cVec cMatrix::operator*(const cVec &y) const
       Matriisi*vektori, saatu vektori palautetaan.
   - int cMatrix::ei_litussa(void)
       Laskee matriisin determinantin.

   Muut aliohjelmat:
   - double kulma_radiaaneiksi(double angle)
       Muuttaa asteina annetun kulman radiaaneiksi.
*************************************************************************/
#include<windows.h>
#include<windowsx.h>
#include<math.h>
#include<stdio.h>
#include"tabhand.h"
#include"mdialog.h"
#include"matriisi.h"
#include"winlin.h"

//cMatrix:n metodit:

cVec cMatrix::luvaton;

double kulma_radiaaneiksi(double angle)
{
  return angle/180.0*M_PI;
}

const cMatrix &cMatrix::kierto(double angle, int axel=1)
{
  diagonaali();
  angle = kulma_radiaaneiksi(angle);
  switch (axel) {
    case 1 : R[1][1]=  cos(angle);  R[1][2]= -sin(angle);        // x-akseli
             R[2][1]=  sin(angle);  R[2][2]= cos(angle); break;
    case 2 : R[0][0]=  cos(angle);  R[0][2]= sin(angle);         // y-akseli
             R[2][0]= -sin(angle);  R[2][2]= cos(angle);  break;
    case 3 : R[0][0]=  cos(angle);  R[0][1]= -sin(angle);        // z-akseli
             R[1][0]=  sin(angle);  R[1][1]= cos(angle);  break;
  }
  return *this;
}

int cMatrix::tee_muunnos(const int xstep,const double dx,const double dy, double factor = 1.0)
// muuttaa origon keskelle ikkunaa, factor on pikselin kerroin y-suuntaan
{
  R[0][0]=xstep;
  R[0][3]=dx;
  R[1][1]=-factor*xstep;
  R[1][3]=dy;
  return 0;
}
//14.07
int cMatrix::ei_litussa(void)
{
  double det=( R[0][0]*(R[1][1]*R[2][2]-R[1][2]*R[2][1])
              -R[0][1]*(R[1][0]*R[2][2]-R[1][2]*R[2][0])
              +R[0][2]*(R[1][0]*R[2][1]-R[1][1]*R[2][0]));
  if (-EPSILON<=det&&det<=EPSILON) return 0;
  return 1;
}

const cMatrix &cMatrix::siirto(const double a=0.0,const double b=0.0,const double c=0.0)
{
  diagonaali();
  R[0][3]=a;
  R[1][3]=b;
  R[2][3]=c;
  return *this;
}

const cMatrix &cMatrix::vaanto(const double a, int b=1) // 2-ulotteinen
{
  diagonaali();
  switch (b){
    case 1 : R[0][1]=a;  break;         // xy-tason vääntö x:n suuntaan
    case 2 : R[1][0]=a;  break;         // xy-tason vääntö y:n suuntaan
    case 3 : R[2][1]=a;  break;         // xy-tason vääntö z:n suuntaan   ??
  }
  return *this;
}

const cMatrix &cMatrix::skaalaus(const double a=1.0,const double b=1.0,const double c=1.0) // ei voi siirtää pois origosta
{
  diagonaali();
  cMatrix apu(a);
  apu[1][1]=b;
  apu[2][2]=c;
  *this*=apu;
  return *this;
}

cVec &cMatrix::operator[](int i)
{
  if (i<0||KOKO<=i) {
    return luvaton;
  }
  return R[i];
}

const cVec &cMatrix::operator[](int i) const
{
  if (i<0||KOKO<=i) {
    return luvaton;
  }
  return R[i];
}

cMatrix &cMatrix::operator=(const cMatrix &M)    //matriisin sijoitus matriisille
{
  int i;
  for(i=0;i<KOKO;i++) {
    if ( M[i]==R[i] ) continue;
    R[i]=M[i];
  }
  return *this;
}

cMatrix cMatrix::operator=(const double i)   //diagonaalimatriisi
{
  cMatrix apu(i);
  return apu;
}

cVec cMatrix :: ref(const int i) const   //palauttaa matriisin sarakkeen.
{
  int j; cVec apu;
  if (i<0||KOKO<=i) {
    return luvaton;
  }
  for(j=0;j<KOKO;j++) apu[j]=R[j][i];
  return apu;
}

cMatrix &cMatrix::operator*=(const cMatrix &M)    //M*A sijoitettuna  M:„„n
{
  int i,j; cVec apu;
  for(j=0;j<KOKO;j++) {
    apu=R[j];
    for(i=0;i<KOKO;i++) R[j][i]=apu*M.ref(i);
  }
  return *this;
}

cMatrix operator*(const cMatrix &M1,const cMatrix &M2)  //matriisi kertaa matriisi
{
  cMatrix apu(M1);
  apu*=M2;
  return apu;
}

cVec cMatrix::operator*(const cVec &y) const
{
  cVec apu; int i;
  for(i=0;i<KOKO;i++) apu[i]=R[i]*y;
  return apu;
}