C++ Matrice类代码示例

Matrice operator-(Matrice A, Matrice B)
{
    int nlA, ncA, nlB, ncB;
    A.GetSize(nlA, ncA);
    B.GetSize(nlB, ncB);
    Matrice result(nlA, ncB);

    if(ncA!=ncB || nlA!=nlB)
    {
        cout << "- Impossible" << endl;
        return result;
    }
    else
    {
        double** m = new double*[nlA];

        for(int i=0; i<nlA ; i++)
        {
            m[i] = new double[ncB];
            for (int j=0; j<ncB; j++)
                m[i][j] = 0;
        }

        for(int i=0; i<nlA ; i++)
            for(int j=0; j<ncB ; j++)
                m[i][j]=(A.GetValue(i,j))-(B.GetValue(i,j));

        result.Set(m);
        return result;
    }
}

Matrice operator*(Matrice A, Matrice B)
{
    int nlA, ncA, nlB, ncB;
    A.GetSize(nlA, ncA);
    B.GetSize(nlB, ncB);
    if(ncA!=nlB)
    {
        cout << "lol les matrice ça ce multiplies pas comme ça fdp" << endl;
    }
    else
    {
        Matrice result(nlA, ncB);
        double** m = new double*[nlA];
        for(int i=0; i<nlA ; i++)
        {
            m[i] = new double[ncB];
        }
        for(int i=0; i<nlA ; i++)
        {
            for(int j=0; j<ncB ; j++)
            {
                for(int k=0; k<ncA ; k++)
                {
                    m[i][j]+=(A.GetValue(i,k))*(B.GetValue(k,j));
                }
            }
        }
        result.Set(m);
        return resultat;
    }
}

int main()
{
    
    Matrice A(2,2);
    A(0,0)=5;
    A(0,1)=4;
    A(1,1)=1;
    A(1,0)=8;
    Matrice B(A); // Construction par copie.
    Matrice C = A*B;
    
    int nlig = rand()%100;
    
    vector<Matrice> Mat_Vect; // Construction normal.
    vector<Matrice> Mat_Vect2; // Construction par copie.
    vector<Matrice> Mat_Vect3; // Construction par copie d'une multiplication.

    
    for (int i = 0; i < 10; i++){
        Matrice A = Matrice(nlig, nlig);
        A.RandomMatrice();
        Mat_Vect.push_back(A);
    }
    for (int i = 0; i < 10; i++){
        Mat_Vect2.push_back(Mat_Vect[i]);
    }
    for (int i = 0; i < 10; i++){
        Mat_Vect3.push_back(Mat_Vect[i]*Mat_Vect2[9-i]);
    }
    
    return 0;
    
}

Matrice BlinkyBlock::getMatrix(const Vecteur &bs) const {
    Matrice mat;

    double sigma = 0.5*((int)position.pt[2]%2);
    mat.setTranslation((position.pt[0]+sigma)*bs[0],(position.pt[1]+sigma)*bs[1],position.pt[2]*bs[2]*M_SQRT1_2);
    return mat;
}

/****************************************************************************
 * Fonction:	Matrice::operateur/
 * Description: Divise tous les éléments de la matrice par une valeur réelle
 * Paramètres:	Valeur à diviser
 * Retour:		Matrice résultante
 ****************************************************************************/
Matrice Matrice::operator/(double valeur)
{
	Matrice result = Matrice(*this);
	for (int i=0; i<lignes_; i++) {
		for (int j=0; j<colonnes_; j++)
			result.matrice_(i,j) /= valeur;
	}
	return result;
}

void testMGD()
{
	Quadruplet pQUAconfig[3];
	pQUAconfig[0] = Quadruplet(PI/2, 2, PI/2, 0);
    pQUAconfig[1] = Quadruplet(0, 0, 0, 1);
	pQUAconfig[2] = Quadruplet(0, 0, 0, 1);

	Matrice m = Robotique::ROBcalculMGD(pQUAconfig, 3);
	m.MATprint();
}

int main()
{
	Matrice A;
	Element elem1(3,0,0);
	Element elem2(2,1,1);
	Element elem3(1,0,4);
	A.ajouterElement(elem1);
	A.ajouterElement(elem2);
	A.ajouterElement(elem3);
	A.afficher();
	A.afficheCreuse();
	return 0;
}

void DrImage::Cut(){
  char cImage[160];
  sprintf(cImage,"Small.png");
  double pixel[4];
  double xBound[2] = {.5,.75};
  double yBound[2] = {.2,.45};
  int xNBound[2];
  int yNBound[2];
  for(int d=0;d<2;d++){
    xNBound[d] = (int)(xBound[d]*NWidth);
    yNBound[d] = (int)(yBound[d]*NHeight);
    printf("%d %d %d %d\n",xNBound[d],NWidth,yNBound[d],NHeight);
  }
  int Dx = xNBound[1]-xNBound[0];
  int Dy = yNBound[1]-yNBound[0];
  double *Plot = new double[Dx*Dy];
  Matematica *Mat = new Matematica;
  //VarData *Var = new VarData;
  Matrice *ImIn = new Matrice(Dx,Dy);
  pngwriter ImageOut(xNBound[1]-xNBound[0],yNBound[1]-yNBound[0],1.0,cImage);
  double Average = 0.;
  double Count = 0.;
  for(int h=yNBound[0];h<yNBound[1];h++){
    for(int w=xNBound[0];w<xNBound[1];w++){
      int hh = h -yNBound[0];
      int ww = w -xNBound[0];
      double Sum = data[0][h*NWidth+w]+data[1][h*NWidth+w]+data[2][h*NWidth+w];
      //Sum *= .5;
      // ImageOut.plot(ww,hh,data[0][h*NWidth+w],data[1][h*NWidth+w],data[2][h*NWidth+w]);
      ImIn->Set(ww,hh,Sum);
      Plot[hh*Dx+ww] = Sum;
    }
  }


  for(int h=0;h<Dy;h++){
    for(int w=0;w<Dx;w++){
      //if(ImIn->Val(w,h) >= 0.)
      ImageOut.plot(w,h,10.*ImIn->Val(w,h),ImIn->Val(w,h),ImIn->Val(w,h));
    }
  }
  ImageOut.close();
  delete [] Plot;
}

/****************************************************************************
 * Fonction:	Matrice::Matrice
 * Description: Constructeur par copie
 * Paramètres:	Matrice à copier
 * Retour:		aucun
 ****************************************************************************/
Matrice::Matrice(const Matrice& uneMatrice)
{
	lignes_ = uneMatrice.lignes_;
	colonnes_ = uneMatrice.colonnes_;
	matrice_.setbounds(0,lignes_-1,0,colonnes_-1);
	for (unsigned int i=0; i<lignes_; i++)
	{
		for (unsigned int j=0; j<colonnes_; j++)
			matrice_(i,j) = uneMatrice.matrice_(i,j);
	}
}

bool operator== (const Matrice<char> &a, const Matrice<char> &b)
{
	for (int i = 0; i < a.GetNbLignes(); i++)
	{
		if (a[i] != b[i])
		{
			return false;
		}
	}
	return true;
}

/*
 * La fonction inverse utilise l'élimination de Gauss-Jordan pour générer une matrice inverse :
 * pour cela on utilise le pseudo-code trouver à cette adresse : http://fr.wikipedia.org/wiki/%C3%89limination_de_Gauss-Jordan#Pseudocode
 * On effectue les opérations sur la matrice à inverser et sur une matrice identité de même dimension.
 * Lorsque l'algorithme est terminé, la matrice identité a pris les valeurs de la matrice inverse.
 * La matrice à inverser a pris les valeurs de sa matrice échelonnée réduite.
 */ 
Matrice Matrice::Inverse() const
{
	int r = -1; //Attention au indices décalés dans notre logiciel (0 -> -1)
	Matrice inversible(*this);
	Matrice resultat = Identite();
	
	for(int j = 0; j < m_colonnes; j++)
	{
		//Recherche du maximum
		int k = r + 1; //<Position du maximum
		for(int i = k + 1; i < m_lignes; i++) // pas besoin de comparer la case de la ligne k avec elle-même
		{
			if(fabs(inversible.ObtenirValeur(i, j)) > fabs(inversible.ObtenirValeur(k, j)))
				k = i;
		}
		
		if(inversible.ObtenirValeur(k, j) != 0.f) //Si le max est != de 0
		{
			//Incrémentation de r
			r++;
			
			//Echange des lignes k et r
			inversible = inversible.InversionLignes(r, k);
			resultat = resultat.InversionLignes(r, k);
			
			//Division de la ligne r par A[r,j]
			float coeff = inversible.ObtenirValeur(r, j); //< A[r,j]
			//On stocke la valeur avant dans la variable coeff car elle est susceptible d'être modifiée par la division
			for(int l = 0; l < m_colonnes; l++)
			{
				inversible.FixerValeur(r, l, inversible.ObtenirValeur(r, l) / coeff);
				resultat.FixerValeur(r, l, resultat.ObtenirValeur(r, l) / coeff);
			}
			
			//On parcourt toutes lignes
			for(int i = 0; i < m_lignes; i++)
			{
				if(i == r) //sauf la ligne r
					continue;
				
				//Soustraction de la ligne i par la ligne r multipliée par le coeff i;j
				float coeffIJ = inversible.ObtenirValeur(i, j); //< A[i,j]
				//Pour les mêmes raisons que l'on garde A[r,j] dans coeff, on garde A[i,j] dans coeffIJ.
				for(int l = 0; l < m_colonnes; l++)
				{
					inversible.FixerValeur(i, l, inversible.ObtenirValeur(i, l) - inversible.ObtenirValeur(r, l) * coeffIJ);
					resultat.FixerValeur(i, l, resultat.ObtenirValeur(i, l) - resultat.ObtenirValeur(r, l) * coeffIJ);
				}
			}
		}
	}
	
	return resultat;
}

bool Binairo::EstLigneEquilibree(Matrice<char> m, int ligne)
{
	// Compter le nombre de fois que la valeur donnée apparaît dans le Ligne
	compteurLigneZERO = 0, compteurLigneUN = 0;
	for (int j = 0; j < m.GetNbColonnes(); j++)
	{
		if (binairoGrille[ligne][j] == '0')
		{
			compteurLigneZERO++;
		}
		if (binairoGrille[ligne][j] == '1')
		{
			compteurLigneUN++;
		}
	}
	if (compteurLigneZERO != compteurLigneUN)
	{
		return false;
	}
	else
	{
		return true;
	}
}

bool Binairo::EstColonneEquilibree(Matrice<char> m, int colonne)
{
	// Compter le nombre de fois que la valeur donnée apparaît dans le Colonne
	compteurColonneZERO = 0, compteurColonneUN = 0;
	for (int i = 0; i < m.GetNbLignes(); i++)
	{
		if (binairoGrille[i][colonne] == '0')
		{
			compteurColonneZERO++;
		}
		if (binairoGrille[i][colonne] == '1')
		{
			compteurColonneUN++;
		}
	}
	if (compteurColonneZERO != compteurColonneUN)
	{
		return false;
	}
	else
	{
		return true;
	}
}

int main()
{
    
    
    cout<<"Welcome to matrix operation program"<<endl;
    
    cout<<"This program is developed for matrix operation, first matrix is read by a file"<<endl;
    
    cout<<"You must give dimensions of second matrice and program will generate a matrix with random values, then you can go to matrix operations."<<endl;
    cout<<endl;
    
    // File handling part
    
    Matrice FileMatrice ;
    
    FileMatrice.readLinesFromFile() ;
    
    cout<< "Here is a matrix with size: "<<FileMatrice.rowSize<<"x"<<FileMatrice.columnSize<<endl;
    
    FileMatrice.printMatrice();
    

    // create a random matrice struct called RandomMatrice
    
    Matrice RandomMatrice ;
    
    // we should get the dimension from the user in this scheme: row x column
    // so I am creating a string with 3 bytes to get it
    
    char getMatriceSize[3] ;
    cout << "Please enter the dimensions of the matrice (e.g. 2x3):" ;
    cin  >> getMatriceSize ;
    cout << "Here is a matrice with size of "<< getMatriceSize << "\n" ;
    //  we can add exception here in case of user enters invalid size
    
    // In order to get the size, I subtsracted ascii value '0' from the char value
    RandomMatrice.rowSize = getMatriceSize[0]-'0';
    //cout << "Row size "<< rowSize << "\n" ;
    
    // Same operation for column size of the matrice
    RandomMatrice.columnSize = getMatriceSize[2]-'0';
    //cout << "Column size "<< columnSize << "\n" ;
    
    // allocate memory for given dimension in random matrice
    RandomMatrice.allocateMemoryForMatriceElements() ;

    // get random values for the matrice
    //for random values
    srand(time(NULL));
    RandomMatrice.getRandomValuesForMatriceElements() ;
    
    
    // print the matrice with new elements
    RandomMatrice.printMatrice() ;

    RandomMatrice.bindMatriceElements() ;
    
       
    
    // Menu
    
    
    bool menuChoice = true;            //  boolean value for menu choice (continue ? (Y or N))
    char operationChoice ;             // char value for menu operations 
    char askIfTheUserWantsToContinueOperations ;
    while (menuChoice){
    
        cout << "\t\t\tMatrice Operation Menu\n" ;
        cout << "Select one of the matrice operations: \n" ;
           
        cout<< "1. Multiply the matrices and print the result to the screen.(M)\n"<<
            "2. Find transpose of the matrices (both) and print them to the screen.(T)\n"<<
            "3. Check if the matrices are symmetric.(S)\n"<<
            "4. Check if the matrices are zero matrix.(Z)\n"<<
            "5. Calculate the determinant of the matrices.(D)\n";
        
        cin>> operationChoice ;
        
        switch (operationChoice) {
            case 'M' | 'm':
                matrixMultiplication(FileMatrice, RandomMatrice);
                break;
            case 'T' | 't':
                //statements
                transpozeOperation(FileMatrice, RandomMatrice);
                break;
            case 'S' | 's':
                //statements
                checkIfSymmetric(FileMatrice, RandomMatrice);
                break;
            case 'Z' | 'z':
                //statements
                checkIfZeroMatrix(FileMatrice, RandomMatrice);
                break;
            case 'D' | 'd':
                //statements
                determinantOperation(FileMatrice, RandomMatrice);
                break;
            default:
                break;
//.........这里部分代码省略.........

/*!
 * \fn  void afficheCalcul(std::string& user, const int type)
 * \brief Affiche Le Calcul de matrice
 */
void afficheCalcul(std::string& user, const int type)
{
	int maxChoix = 0, choix1 = 0, choix2 = 0, val = 0;
	double v = 0;
	std::string mat1 = "", mat2 = "", info = "";
	Matrice *A = NULL, *B = NULL;

	maxChoix = afficheSM(type);

	if (type == 1 || type == 2 || type == 3) {
		if(maxChoix > 1)	  std::cout << "  - Veuillez indiquer votre choix (1 à " << maxChoix << ", r, q ou x[choix] pour supprimer) : ";
		else if(maxChoix == 1) std::cout << "  - Veuillez indiquer votre choix (1 , r, q ou x1 pour supprimer) : ";
		else		  std::cout << "  - Veuillez créer des matrices (r ou q) : ";

		getline(std::cin, user);
		choix1 = atoi(user.c_str()); // on change string en int

		std::cout << "  - Veuillez indiquer votre choix pour le squalaire : ";
		getline(std::cin, user);
		if (type == 3) {
			val = atoi(user.c_str());
		}
		else {
			v = atof(user.c_str());
		}
	}
	else if (type == 4 || type == 5 || type == 6 || type == 7) {
		if (maxChoix > 1) {
			std::cout << "  - Veuillez indiquer votre choix comme matrice (1 à " << maxChoix << ", r, q ou x[choix] pour supprimer)" << std::endl;
			std::cout << "  - Veuillez indiquer votre choix pour la première matrice : ";
			getline(std::cin, user);
			choix1 = atoi(user.c_str()); // on change string en int

			if (user[0] != 'x') {
				std::cout << "  - Veuillez indiquer votre choix pour la deuxieme matrice : ";
				getline(std::cin, user);
				choix2 = atoi(user.c_str()); // on change string en int
			}
		}
		else if (maxChoix == 1) {
			std::cout << "  - Veuillez créer des matrices ou le calcul ce fera sur la matrice elle meme (1 , r, q ou x1 pour supprimer) : ";
			getline(std::cin, user);
			choix1 = atoi(user.c_str()); // on change string en int
			choix2 = choix1;
		}
		else {
			std::cout << "  - Veuillez créer des matrices (r ou q)";
		}
	}

	if (user != "q" && user != "r" && user[0] != 'x') {
		if (((type == 1 || type == 2 || type == 3) && choix1 <= maxChoix && choix1 > 0) || ((type == 4 || type == 5 || type == 6 || type == 7) && choix1 <= maxChoix && choix1 > 0 && choix2 <= maxChoix && choix2 > 0)) //Test si le choix est valide
		{
			mat1 = trouveFichier(choix1);
			A = new Matrice("./mat/"+mat1);

			if (type == 4 || type == 5 || type == 6 || type == 7) {
				mat2 = trouveFichier(choix2);
				B = new Matrice("./mat/"+mat2);
			}

			if (type == 1) {
				*A *= v;
			}
			else if (type == 2) {
				*A /= v;
			}
			else if (type == 3) {
				A->Pow(val);
			}
			else if (type == 4) {
				*A += *B;
			}
			else if (type == 5) {
				*A -= *B;
			}
			else if (type == 6) {
				*A *= *B;
			}
			else if (type == 7) {
				A->Hadamard(*B);
			}

			std::cout << std::endl << *A << std::endl << "  - Voulez vous sauvegarder la matrice ? (y, n) : ";
			getline(std::cin, user);

			if (user == "y") {
				std::cout << "  - Veuillez donner un nom à la matrice : ";
				getline(std::cin, user);

				saveBdd(user, A);			
			}

			delete A;
			A = NULL;
			delete B;
//.........这里部分代码省略.........