Ubuntu-fr

double (*pf) (int, int) = &ma_fonction;

double (*pf) (int, int) = ma_fonction;

Program received signal SIGSEGV, Segmentation fault.
0x0000000000400b6f in afficher (l=0x0) at main.c:87
87		printf("%d\t",l->v);

#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));
}

#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));
}

#define sched_priority  __sched_priority

printf("Valeur de param = %d\n", param.sched_priority);

 57 linux:
 58         $(MAKE) $(MFLAGS) -f Makefile.arch \
 59         "prog   = medit-2.3-linux"\
 60         "CC     = gcc" \
 61         "CFLAGS = -O3 -ansi -fexpensive-optimizations \
 62                   -Wuninitialized -Wunused -Winline -Wshadow" \
 63         "LDFLAGS= -s -static-libgcc " \
 64         "INCDIR = -I. -I./sources/" \
 65         "XLIBS  = -L/usr/X11R6/lib -lXmu -lXext -lX11" \
 66         "GL_LIB   = -lGL" \
 67         "GLU_LIB  = -lGLU" \
 68         "GLUT_LIB = -lglut" \
 69         "EXEDIR = ."

 1 # makefile for medit
  2 
  3 # objects list
  4 src    = $(wildcard *.c)
  5 objs   = $(src:.c=.o)
  6 header = $(wildcard *.h)
  7 
  8 # working dirs
  9 SRCDIR = sources
 10 OBJDIR = objects
 11 ARCDIR = archives
 12 DIRDIR = objects $(OBJDIR) $(ARCDIR)
 13 VPATH  = $(SRCDIR)
 14 
 15 # objects list
 16 src    = $(wildcard $(SRCDIR)/*.c)
 17 header = $(wildcard $(SRCDIR)/*.h)
 18 objs   = $(patsubst $(SRCDIR)%,$(OBJDIR)%,$(src:.c=.o))
 19 
 20 #.SILENT:
 21 
 22 $(prog): $(DIRDIR) $(objs)
 23         echo "#define COMPIL " '"' `date` '"' > $(SRCDIR)/compil.date
 24         $(CC) -c $(CFLAGS) $(INCDIR) $(SRCDIR)/medit.c -o $(OBJDIR)/medit.o
 25         $(CC) -o $@ $(objs) $(LDFLAGS) $(GLUT_LIB) $(GL_LIB) $(GLU_LIB) $(XLIBS) -lm
 26         mv $@ $(EXEDIR)
 27 
 28 $(OBJDIR)/%.o: $(SRCDIR)/%.c
 29         $(CC) -c $(CFLAGS) $(INCDIR) $< -o $@
 30 
 31 $(objs): $(header)
 32 
 33 $(DIRDIR):
 34         @[ -d $@ ] || mkdir $@
 35 
 36 clean:
 37         -rm $(objs) $(EXEDIR)/$(prog)
38 
 39 tar:$(DIRDIR)
 40         tar czf $(ARCDIR)/medit.`date +"%Y.%m.%d"`.tgz sources makefile
 41 
 42 target: $(prog)
 43 

my_class obj4{my_class(1,2)};