Ubuntu-fr

Lrnv

[SOLVED] Besoin d'un coup de main en C++

Bonjour tout le monde !
Pour ma fac, je doit coder l'inversion d'une matrice en C++. La forme du code est relativement imposée : algorythme de gauss-jordan, utilisation de vecteur dynamiques et passage par adresse. Bon, le problème c'est que j'ai des segfault dont je ne sais que faire

Voila le code :

#include <iostream>
#include <vector>
#include <string.h>

using namespace std;


float valeur_absolue(float k)
{
    if (k>0) { return k; } else { return -k; }
}


void afficher_matrice(vector<vector<float> > matrice)
// AFFICHAGE D'UNE MATRICE
{
    for (unsigned int i=0;i<matrice.size();i++){ //parcours sur les lignes : l'utilisation de .size permet de trater n'importe quelle taille de matrice.
        for (unsigned int j=0;j<matrice[i].size();j++){ // parcourt sur les colones, meme argument.
            cout << matrice[i][j] << "    "; // affichage...
        }
        cout << "\n\n"; // mise en forme.

    }
}

vector<vector<float> > matrice_identite(int lignes, int colones)
// CRÉATION D'UNE MATRICE IDENTITE
{
    vector<vector<float> > matrice;
    for (int i=0;i<lignes;i++)
    {
        matrice.push_back(vector<float>(colones));
    }

    // remplissage
    for (unsigned int i=0;i<lignes;i++) { for (unsigned int j=0;j<colones;j++) {
        if ( i == j ) { matrice[i][j] = 1; }
        else { matrice[i][j] = 0; }
    }}

    return matrice;
}

void creer_matrice(vector<vector<float> > &matrice)
//CRÉATION D'UNE MATRICE AVEC REMPLISSAGE
{
    int lignes,colones;
    cout << "Vous allez creer une matrice, commencez par renseigner sa taille :\nNombre de lignes ? ";
    cin >> lignes;
    cout << "\nNombre de colones ? ";
    cin >> colones;
    for (int i=0;i<lignes;i++){ // ici on fait des pushback pour intialiser notre tableau, ce sera une matrice ligne*colone
            matrice.push_back(vector<float>(colones));

    }
    cout << "\nVotre matrice a bien ete cree. Merci maitnenat de la remplir :";
    for (int i=0;i<lignes;i++){
        for(int j=0;j<colones;j++){
            cout << "\nLigne " << i << " Colone " << j << " : ";
            cin >> matrice[i][j];
        }
    }
    cout << "Votre matrice a bien ete remplie\n";
        //afficher_matrice(matrice);

}

// Commençons par coder les opération éllémentaires utilisées par l'algorythme de gauss-jordan :

void echanger_deux_lignes(vector<vector<float> > &matrice, int i, int j)
// ECHANGE DE DEUX LIGNES D'UNE MATRICE
{
    float relai;
    for (unsigned int k=0;k<matrice.size();k++) // on parcourt sur les colones pour inverser les valeurs une par unes
    {
        relai=matrice[i][k];
        matrice[i][k]=matrice[j][k];
        matrice[j][k]=relai;
    }
}

void multiplier_ligne_par_scalaire(vector<vector<float> > &matrice, int numligne, float scalaire)
// MULTIPLICATION D'UNE LIGNE D'UNE MATRICE PAR UN SCALAIRE
{
    for (unsigned int k=0;k<matrice.size();k++)
    {
        matrice[numligne][k]=matrice[numligne][k]*scalaire;
    }
}

void soustraire_mult_ligne_a_autre(vector<vector<float> > &matrice, int ligneL, int ligneM, float scalaire)
// SOUSTRACTION DU MULTIPLE D'UN SCALAIRE PAR UNE LIGNE L A UNE LIGNE M
{
    for (unsigned int i=0;i<matrice.size();i++)
    {
        matrice[ligneM][i]-=matrice[ligneL][i]*scalaire;
    }
}

// Passons maitnenant a l'inversion en elle meme : il faudra appliquer l'agorythme sur deux matrice ( celle fournie et l'identitée )
vector<vector<float> > inverse_matrice(vector<vector<float> > &matrice)
// INVERSION D'UNE MATRICE VIA GAUSS-JORDAN
{
    // Notons m la taille de la matrice
    int m = matrice.size();
    // créons une matrice identitée a laquelle on apliquera la meme chose
    vector<vector<float> > ident=matrice_identite(m,m);
    int r=0;
    
    // c'est partit pour l'algorythme de gauss-jordan :
    for (int j=0;j<m;j++)
    {
        float max_colone=valeur_absolue(matrice[0][j]);
        int k=0;
        for (int i=r;i<m;i++)
        {
            if ( valeur_absolue(matrice[i][j]) > max_colone ) 
            {
                max_colone = valeur_absolue(matrice[i][j]); k=i;
            }   
        }
        if ( matrice[k][j] != 0 )
        {
            r+=1;
            multiplier_ligne_par_scalaire(matrice,k,1/matrice[k][j]);
            multiplier_ligne_par_scalaire(ident,k,1/matrice[k][j]);
            echanger_deux_lignes(matrice,k,r);
            echanger_deux_lignes(ident,k,r);
            for ( int i=0;i<m;i++)
            {
                if ( i != r )
                { 
                    soustraire_mult_ligne_a_autre(matrice,i,r,matrice[i][j]);
                    soustraire_mult_ligne_a_autre(ident,i,r,matrice[i][j]);
                }
            }
        }
    }
return ident;
}

int main()
{
    vector<vector<float> > matrice;
    creer_matrice(matrice);
    afficher_matrice(matrice);
    afficher_matrice(inverse_matrice(matrice));
}

Ça compile comme il faut avec g++, mais ne s'execute pas et gdb me dit :

(gdb) run
Starting program: /media/oskar/01D10F73E906D5D0/Documents/Work isfa/C++/TD5/a.out 
Vous allez creer une matrice, commencez par renseigner sa taille :
Nombre de lignes ? 2

Nombre de colones ? 2

Votre matrice a bien ete cree. Merci maitnenat de la remplir :
Ligne 0 Colone 0 : 1

Ligne 0 Colone 1 : 0

Ligne 1 Colone 0 : 0

Ligne 1 Colone 1 : 1
Votre matrice a bien ete remplie
1    0    

0    1    


Program received signal SIGSEGV, Segmentation fault.
0x0000000000401203 in echanger_deux_lignes (matrice=std::vector of length 2, capacity 2 = {...}, i=0, j=2) at main.cpp:77
77	        matrice[i][k]=matrice[j][k];
(gdb) 

Que faire ? Ça fait plusieurs heure que je tourne en rond autour du problème sans y arriver ><" Ca fais déja deux fois que je me dit "Bon, je reprend une feuille blanche ça ira mieux que de re-bidouiller du vieux code"... Sans succes

Dernière modification par Lrnv (Le 07/12/2015, à 13:34)

---

Hardware : i7/8goDDR3 en desktop /// Lenovo thinkpad yoga 2 13 en laptop.
OSs : *buntu on desktop, arch / win8 on laptop
Mon Github

pingouinux

Re : [SOLVED] Besoin d'un coup de main en C++

Bonjour,
Une impression de i, j dans echanger_deux_lignes, pour une matrice 2×2, montre que l'erreur se produit quand j=2.
C'est la valeur de r dans inverse_matrice qui doit être erronée lors de cet appel :

            echanger_deux_lignes(matrice,k,r);

Compte anonymisé

Re : [SOLVED] Besoin d'un coup de main en C++

Bonjour, ça n'a rien à voir, mais il y a un beau warning

matrix.cpp:36:28: attention : comparaison entre des expressions entières signée et non signée [-Wsign-compare]

Soit tu bosses avec des unsigned int soit avec des int, mais pas les deux mélangés dans une boucle.
J'ai corrigé cette partie de code.

vector<vector<float> > matrice_identite(unsigned int lignes, unsigned int colones)
// CRÉATION D'UNE MATRICE IDENTITE // matrix.cpp:36:28: attention : comparaison entre des expressions entières signée et non signée [-Wsign-compare] --> Warning corrigé
{
    vector<vector<float> > matrice;
    for (unsigned int i=0;i<lignes;i++)
    {
        matrice.push_back(vector<float>(colones));
    }

    // remplissage
    for (unsigned int i=0;i<lignes;i++) { for (unsigned int j=0;j<colones;j++) {
        if ( i == j ) { matrice[i][j] = 1; }
        else { matrice[i][j] = 0; }
    }}

    return matrice;
}

grigouille

Re : [SOLVED] Besoin d'un coup de main en C++

void echanger_deux_lignes(vector<vector<float> > &matrice, int i, int j)
// ECHANGE DE DEUX LIGNES D'UNE MATRICE
{
    float relai;
    for (unsigned int k=0;k<matrice.size();k++) // on parcourt sur les colones pour inverser les valeurs une par unes
    {
        relai=matrice[i][k];
        matrice[i][k]=matrice[j][k];
        matrice[j][k]=relai;
    }
}

k est l'indice de matrice, donc seul matrice[k] est valide.

Conseil : crée une class Matrix.

---

Debian (xfce) 12
HP LaserJet M1132 MFP

no_spleen

Re : [SOLVED] Besoin d'un coup de main en C++

Bonjour,

Comme Pingouinux te l'a renseigné, le problème vient de ta variable r. Tu l'initializes à 0 en dehors de ta boucle sur la matrice, et tu l'incrémentes de 1 à l'intérieur à chaque passage -> à la deuxième ligne, r devient égal à 2, ce qui est en dehors des indexes de ta matrices.

Pour ce qui est du style, il y a pas mal à corriger dans ton code. J'ai changé 2/3 trucs dans le code ci-dessous. Je ne dis pas que tout ce que j'ai fait est à garder, ce sont juste des idées en vracs.

PS : je n'ai pas vérifié la bonne implémentation de l'algorithme !
PSS : Est-ce que l'algorithme de Gauss ne s'applique pas seulement aux matrices carrées ? Si oui, pas besoin de demander le nombre de lignes ET de colonnes.

Changements :
- J'ai placé l'initialisation de r dans ta boucle
- Plutôt que de taper vector<vector<float>> partout, mieux vaux effectuer un define en début de code
- Comme renseigné par grigouille, il vaudrait mieux définir une vraie classe matrice, mais j'imagine que ce n'est pas le but de l'exercice
- pourquoi définir une fonction valeur absolue alors qu'il en existe une dans la librairie standard ?
- pour transformer tous les éléments d'un container, il vaut mieux utiliser std::transform que de faire une boucle

#include <iostream>
#include <vector>
#include <string.h>
#include <cmath>
#include <algorithm>

using namespace std;

using Matrice = std::vector< std::vector<float> >;

void afficher_matrice(Matrice matrice) 
{
	for (auto const &row : matrice){ 
		for (auto const &item : row){ 
			cout << item << "    "; 
		}
		cout << "\n\n"; 
	}
}

Matrice matrice_identite(int lignes, int colones)
	// CRÉATION D'UNE MATRICE IDENTITE
{
	Matrice matrice;
	for (int i=0;i<lignes;i++)
	{
		matrice.push_back(vector<float>(colones));
	}

	// remplissage
	for (unsigned int i=0;i<lignes;i++) { for (unsigned int j=0;j<colones;j++) {
		if ( i == j ) { matrice[i][j] = 1; }
		else { matrice[i][j] = 0; }
	}}

	return matrice;
}

void creer_matrice(Matrice &matrice)
	//CRÉATION D'UNE MATRICE AVEC REMPLISSAGE
{
	int lignes,colones;
	cout << "Vous allez creer une matrice, commencez par renseigner sa taille :\nNombre de lignes ? ";
	cin >> lignes;
	cout << "\nNombre de colones ? ";
	cin >> colones;
	for (int i=0;i<lignes;i++){ // ici on fait des pushback pour intialiser notre tableau, ce sera une matrice ligne*colone
		matrice.push_back(vector<float>(colones));

	}
	cout << "\nVotre matrice a bien ete cree. Merci maitnenat de la remplir :";
	for (int i=0;i<lignes;i++){
		for(int j=0;j<colones;j++){
			cout << "\nLigne " << i << " Colone " << j << " : ";
			cin >> matrice[i][j];
		}
	}
	cout << "Votre matrice a bien ete remplie\n";
	//afficher_matrice(matrice);

}

// Commençons par coder les opération éllémentaires utilisées par l'algorythme de gauss-jordan :

void echanger_deux_lignes(Matrice &matrice, int i, int j)
	// ECHANGE DE DEUX LIGNES D'UNE MATRICE
{
	float relai;
	for (unsigned int k=0;k<matrice.size();k++) // on parcourt sur les colones pour inverser les valeurs une par unes
	{
		relai=matrice[i][k];
		matrice[i][k]=matrice[j][k];
		matrice[j][k]=relai;
	}
}

void multiplier_ligne_par_scalaire(Matrice &matrice, int numligne, float scalaire)
	// MULTIPLICATION D'UNE LIGNE D'UNE MATRICE PAR UN SCALAIRE
{
	std::transform(begin(matrice[numligne]),end(matrice[numligne]),begin(matrice[numligne]),
			[&scalaire](auto x){return x*scalaire;});
}

void soustraire_mult_ligne_a_autre(Matrice &matrice, int ligneL, int ligneM, float scalaire)
	// SOUSTRACTION DU MULTIPLE D'UN SCALAIRE PAR UNE LIGNE L A UNE LIGNE M
{
	std::transform(begin(matrice[ligneL]) , end(matrice[ligneL]),
                       begin(matrice[ligneM]) , begin(matrice[ligneL]),
                       [&scalaire](auto l , auto m){return l -= m*scalaire;});
}

// Passons maitnenant a l'inversion en elle meme : il faudra appliquer l'agorythme sur deux matrice ( celle fournie et l'identitée )
Matrice inverse_matrice(Matrice &matrice)
	// INVERSION D'UNE MATRICE VIA GAUSS-JORDAN
{
	// Notons m la taille de la matrice
	int m = matrice.size();
	// créons une matrice identitée a laquelle on apliquera la meme chose
	Matrice ident=matrice_identite(m,m);

	// c'est partit pour l'algorythme de gauss-jordan :
	for (int j=0;j<m;++j)
	{
		float max_colone=abs(matrice[0][j]);
		int k=0;
		int r=0;
		for (int i=r;i<m;i++)
		{
			if ( abs(matrice[i][j]) > max_colone ) 
			{
				max_colone = abs(matrice[i][j]); k=i;
			}   
		}
		if ( matrice[k][j] != 0 )
		{
			r+=1;
			multiplier_ligne_par_scalaire(matrice,k,1/matrice[k][j]);
			multiplier_ligne_par_scalaire(ident,k,1/matrice[k][j]);
			echanger_deux_lignes(matrice,k,r);
			echanger_deux_lignes(ident,k,r);
			for ( int i=0;i<m;i++)
			{
				if ( i != r )
				{ 
					soustraire_mult_ligne_a_autre(matrice,i,r,matrice[i][j]);
					soustraire_mult_ligne_a_autre(ident,i,r,matrice[i][j]);
				}
			}
		}
	}
	return ident;
}

int main()
{
	Matrice matrice;
	creer_matrice(matrice);
	afficher_matrice(matrice);
	afficher_matrice(inverse_matrice(matrice));
}

Dernière modification par no_spleen (Le 05/12/2015, à 13:39)

Lrnv

Re : [SOLVED] Besoin d'un coup de main en C++

Tout d'abord merci a vous 3 pour votre temps, merci pinguinux d'avoir spotted l'erreur, et merci beaucoup no_spleen pour tes conseils

J'ai du coup essayer de compiler ton code, quelques erreurs :

$ g++ main.cpp
main.cpp:8:7: error: expected nested-name-specifier before ‘Matrice’
 using Matrice = std::vector< std::vector<float> >;
       ^
main.cpp:10:23: error: variable or field ‘afficher_matrice’ declared void
 void afficher_matrice(Matrice matrice) 
                       ^
main.cpp:10:23: error: ‘Matrice’ was not declared in this scope
$

j'ai l'impression qu'il veut un truc du type std::Matrice, mais evidement ça marche pas
D'autre part, je n'ai pas vraiment compris les trasnform/begin, si tu pouvais m'expliquer ?

PS:
Par contre :

$ g++ main.cpp -std=gnu++11
main.cpp: In function ‘void multiplier_ligne_par_scalaire(Matrice&, int, float)’:
main.cpp:79:102: error: use of ‘auto’ in lambda parameter declaration only available with -std=c++14 or -std=gnu++14
  std::transform(begin(matrice[numligne]),end(matrice[numligne]),begin(matrice[numligne]),[&scalaire](auto x){ret
                                                                                                      ^
main.cpp: In function ‘void soustraire_mult_ligne_a_autre(Matrice&, int, int, float)’:
main.cpp:87:36: error: use of ‘auto’ in lambda parameter declaration only available with -std=c++14 or -std=gnu++14
                        [&scalaire](auto l , auto m){return l -= m*scalaire;});
                                    ^
main.cpp:87:45: error: use of ‘auto’ in lambda parameter declaration only available with -std=c++14 or -std=gnu++14
                        [&scalaire](auto l , auto m){return l -= m*scalaire;});
                                             ^
$ g++ main.cpp -std=gnu++14
$ 

en c++14 ça compile ! Désolé.

Par contre j'ai l'impression a l'utilisation que l'algorythme me renvoit la matrice identitée dans 100% des cas, ce qui n'etais pas tout a fais le but...

Dernière modification par Lrnv (Le 05/12/2015, à 14:34)

---

Hardware : i7/8goDDR3 en desktop /// Lenovo thinkpad yoga 2 13 en laptop.
OSs : *buntu on desktop, arch / win8 on laptop
Mon Github

no_spleen

Re : [SOLVED] Besoin d'un coup de main en C++

Salut !

Effectivement, c'est du C++14, il faut compiler avec l'option -std=C++14.

J'ai aussi testé un peu après avoir posté, et ce n'est clairement pas correct. Mais cela, c'est ton exercice, on ne va pas le faire à ta place :-)

Côté style, il y a aussi une fonction swap pour échanger les valeurs de deux containers, donc tu peux écrire

void echanger_deux_lignes(Matrice &matrice, int i, int j)
{
        swap(matrice[i],matrice[j]);
}

Plutot que d'écrire le swap à la main.

no_spleen

Re : [SOLVED] Besoin d'un coup de main en C++

Bon,

En fait, le problème vient de m'apparaitre, alors je lache le morceau (je pense que les modifs sont assez claires, mais n'hésite pas à poser des questions).

#include <iostream>
#include <vector>
#include <string.h>
#include <cmath>
#include <algorithm>

using namespace std;

using Row = std::vector<float>;
using Matrice = std::vector< Row >;

void afficher_matrice(const Matrice &matrice) 
{
	for (auto const &row : matrice){ 
		for (auto const &item : row){ 
			cout << item << "    "; 
		}
		cout << "\n\n"; 
	}
}


Matrice matrice_identite(int n)
{
	Matrice matrice(n,Row(n,0.0));

	for (auto i=0 ; i < n ; ++i){
		matrice[i][i] = 1.0;
	}

	return matrice;
}

Matrice creer_matrice()
{
	int n;
	cout << "Vous allez creer une matrice, commencez par renseigner sa dimension ";
	cin >> n;

	Matrice matrice(n,Row(n));

	cout << "\nVotre matrice a bien ete cree. Merci maitenant de la remplir :";
	for (int i=0;i<n;++i){
		for(int j=0;j<n;++j){
			cout << "\nLigne " << i << " Colone " << j << " : ";
			cin >> matrice[i][j];
		}
	}
	cout << "Votre matrice a bien ete remplie\n";
	return matrice;

}

// Commençons par coder les opération éllémentaires utilisées par l'algorythme de gauss-jordan :

void echanger_deux_lignes(Matrice &matrice, int i, int j)
{
	swap(matrice[i],matrice[j]);
}

void multiplier_ligne_par_scalaire(Matrice &matrice, int numligne, float scalaire)
{
	std::transform(begin(matrice[numligne]),end(matrice[numligne]),begin(matrice[numligne]),
			[scalaire](auto x){return x*scalaire;});
}

void soustraire_mult_ligne_a_autre(Matrice &matrice, int ligneL, int ligneM, float scalaire)
{
	std::transform(begin(matrice[ligneL]) , end(matrice[ligneL]),
		       begin(matrice[ligneM]) , begin(matrice[ligneL]),
		       [scalaire](auto l , auto m){return l -= m*scalaire;});
}

// gauss-jordan 
Matrice inverse_matrice(Matrice &matrice)
{
	int m = matrice.size();
	Matrice ident=matrice_identite(m);

	int r=-1;
	for (int j=0;j<m;++j)
	{
		float max_colone=abs(matrice[0][j]);
		int k=0;
		for (int i=r+1;i<m;++i)
		{
			if ( abs(matrice[i][j]) > max_colone ) 
			{
				max_colone = abs(matrice[i][j]); k=i;
			}   
		}
		if ( matrice[k][j] != 0 )
		{
			r+=1;
			auto val = matrice[k][j];
			multiplier_ligne_par_scalaire(matrice,k,1.0/val);
			multiplier_ligne_par_scalaire(ident,k,1.0/val);
			echanger_deux_lignes(matrice,k,r);
			echanger_deux_lignes(ident,k,r);
			for ( int i=0;i<m;++i)
			{
				if ( i != r )
				{ 
					val = matrice[i][j];
					soustraire_mult_ligne_a_autre(matrice,i,r,val);
					soustraire_mult_ligne_a_autre(ident,i,r,val);
				}
			}
		}
	}
	return ident;
}

int main()
{
	auto matrice = creer_matrice();
	afficher_matrice(matrice);
	afficher_matrice(inverse_matrice(matrice));
}

En gros :
- r initialisé à -1
- passage par une variable intermédiaire avant l'appel aux fonctions multiplier_ligne_par_scalaire et soustraire_mult_ligne_a_autre, car sinon le premier appel modifie la valeur du scalaire que tu utilises pour le deuxième appel.

Le reste des modifications est juste cosmétique. J'ai modifié le code pour travailler sur des matrices carrées, à toi de voir si c'est correct (c'est un peu loin pour moi, mais on n'inverse que des matrices carrées non ?).

Dernière modification par no_spleen (Le 05/12/2015, à 14:58)

Lrnv

Re : [SOLVED] Besoin d'un coup de main en C++

Ok effictivement ton code compile.

Alors si j'ai bien comrpis : Finalement l'initialisation du r doit bien etre en dehors de la boucle, mais du coup il faut l'initialiser a -1;
+ quelques problèmes de passage par adresse dans les petites fonctions
+ la fonction swap : Genial, merci beaucoup

Je n'ai toujours pas compris :
1° L'utilisation de std::transform
2° Le coup de "auto" : Cela sert a typer une variable en fonction du contexte de son utilisation, c'est bien ça ?

PS : Sur le plan mathématique ( La c'est mon domaine ) on inverse normalement que des matrice carrée, bien qu'il ne soit pas faux et souvent utile d'appliquer le meme algorythme a des matrices rectangles.

l'agorythme de gauss n'etais a la base qu'une algo de resolution de systeme linéaire et pas du tout un algo d'inversion, il peut très bien s'appliquer a des systemes linéaires avec plus de colones que de ligne ( sous-determinés ) ou l'inverse ( sur-determinés ). Le seul défaut est que dans un cas on arrivera pas au bout, et dans l'autre on y arrivera trop tot.

Ceci dit il existe un concept de pseudo-inverse, qui n'a pour seul condition d'existance que les colones de la matrices soit linéairement indépendantes. A * A(transposée) est alors inversible, et on pose la peudo inverse de A comme etant son inverse fois la transposée de A.

Dernière modification par Lrnv (Le 05/12/2015, à 15:24)

---

Hardware : i7/8goDDR3 en desktop /// Lenovo thinkpad yoga 2 13 en laptop.
OSs : *buntu on desktop, arch / win8 on laptop
Mon Github

no_spleen

Re : [SOLVED] Besoin d'un coup de main en C++

Alors,

std::transform permet d'appliquer une fonction sur tous les membres d'un/plusieurs containers. Tu trouveras la syntaxe facilement sur internet. Pour la raison de son utilisation, tout est dit ici.

Auto permet de laisser le compilateur déterminer le type d'une variable. D'autres explications ici.

Dans ma version du code, j'utilise aussi des lambda, une autre facilité de C++11. N'hésite pas à faire quelques recherches sur google.

Bon week end !

Destroyers

Re : [SOLVED] Besoin d'un coup de main en C++

Désolé pour le déterrage, mais:

@no_spleen
Y a-t-il une différence quelconque entre using et typedef ?

using Row = std::vector<float>;
using Matrice = std::vector< Row >;

typedef Row std::vector<float>;
typedef Matrice std::vector< Row >;

grigouille

Re : [SOLVED] Besoin d'un coup de main en C++

Aucune différence. using c'est du c++11

---

Debian (xfce) 12
HP LaserJet M1132 MFP