matrice.c File Reference

#include <stdio.h>
#include <stdlib.h>
#include "linear_assert.h"
#include "boolean.h"
#include "arithmetique.h"
#include "matrice.h"

Include dependency graph for matrice.c:

Go to the source code of this file.

Functions
void	matrice_transpose (matrice a, matrice a_t, int n, int m)
	package matrice More...
void	matrice_multiply (matrice a, matrice b, matrice c, int p, int q, int r)
	void matrice_multiply(matrice a, matrice b, matrice c, int p, int q, int r): multiply rational matrix a by rational matrix b and store result in matrix c More...
void	matrice_normalize (matrice a, int n, int m)
	void matrice_normalize(matrice a, int n, int m) More...
void	matrice_normalizec (matrice MAT, int n, int m)
	void matrice_normalizec(matrice MAT, int n, int m): Normalisation des coefficients de la matrice MAT, i.e. More...
void	matrice_swap_columns (matrice matrix, int n, int m, int c1, int c2)
	void matrice_swap_columns(matrice matrix, int n, int m, int c1, int c2): exchange columns c1,c2 of an (nxm) rational matrix More...
void	matrice_swap_rows (matrice a, int n, int m, int r1, int r2)
	void matrice_swap_rows(matrice a, int n, int m, int r1, int r2): exchange rows r1 and r2 of an (nxm) rational matrix a More...
void	matrice_assign (matrice A, matrice B, int n, int m)
	void matrice_assign(matrice A, matrice B, int n, int m) Copie de la matrice A dans la matrice B More...
bool	matrice_egalite (matrice A, matrice B, int n, int m)
	bool matrice_egalite(matrice A, matrice B, int n, int m) test de l'egalite de deux matrices A et B; elles doivent avoir ete normalisees au prealable pour que le test soit mathematiquement exact More...
void	matrice_nulle (matrice Z, int n, int m)
	void matrice_nulle(matrice Z, int n, int m): Initialisation de la matrice Z a la valeur matrice nulle More...
bool	matrice_nulle_p (matrice Z, int n, int m)
	bool matrice_nulle_p(matrice Z, int n, int m): test de nullite de la matrice Z More...
bool	matrice_diagonale_p (matrice Z, int n, int m)
	bool matrice_diagonale_p(matrice Z, int n, int m): test de nullite de la matrice Z More...
bool	matrice_triangulaire_p (matrice Z, int n, int m, bool inferieure)
	bool matrice_triangulaire_p(matrice Z, int n, int m, bool inferieure): test de triangularite de la matrice Z More...
bool	matrice_triangulaire_unimodulaire_p (matrice Z, int n, bool inferieure)
	bool matrice_triangulaire_unimodulaire_p(matrice Z, int n, bool inferieure) test de la triangulaire et unimodulaire de la matrice Z. More...
void	matrice_substract (matrice a, matrice b, matrice c, int n, int m)
	void matrice_substract(matrice a, matrice b, matrice c, int n, int m): substract rational matrix c from rational matrix b and store result in matrix a More...
void	matrice_soustraction_colonne (matrice MAT, int n, int m __attribute__((unused)), int c1, int c2, Value x)
	void matrice_soustraction_colonne(matrice MAT,int n,int m,int c1,int c2,int x): Soustrait x fois la colonne c2 de la colonne c1 Precondition: n > 0; m > 0; 0 < c1, c2 < m; Effet: c1[0..n-1] = c1[0..n-1] - x*c2[0..n-1]. More...
void	matrice_soustraction_ligne (matrice MAT, int n, int m, int r1, int r2, Value x)
	void matrice_soustraction_ligne(matrice MAT,int n,int m,int r1,int r2,int x): Soustrait x fois la ligne r2 de la ligne r1 Precondition: n > 0; m > 0; 0 < r1, r2 < n; Effet: r1[0..m-1] = r1[0..m-1] - x*r2[0..m-1] More...

Function Documentation

matrice_assign()

void matrice_assign	(	matrice	A,
		matrice	B,
		int	n,
		int	m
	)

void matrice_assign(matrice A, matrice B, int n, int m) Copie de la matrice A dans la matrice B

Les parametres de la fonction :

int A[] : matrice !int B[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice

Ancien nom: mat_dup

Definition at line 264 of file matrice.c.

{
    int i, size=n*m;
    for (i = 0 ;i<=size;i++)
        B[i] = A[i];
}

References B.

Referenced by matrice_hermite(), and matrice_smith().

Here is the caller graph for this function:

matrice_diagonale_p()

bool matrice_diagonale_p	(	matrice	Z,
		int	n,
		int	m
	)

bool matrice_diagonale_p(matrice Z, int n, int m): test de nullite de la matrice Z

QQ i dans [1..n] QQ j dans [1..n] Z(i,j) == 0 && i != j || i == j

Les parametres de la fonction :

int Z[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice

Definition at line 362 of file matrice.c.

{
    int i,j;
 
    for (i=1;i<=n;i++)
        for (j=1;j<=m;j++)
            if(i!=j && value_notzero_p(ACCESS(Z,n,i,j)))
                return(false);
    return(true);
}

References ACCESS, and value_notzero_p.

Referenced by matrice_diagonale_inversion().

Here is the caller graph for this function:

matrice_egalite()

bool matrice_egalite	(	matrice	A,
		matrice	B,
		int	n,
		int	m
	)

bool matrice_egalite(matrice A, matrice B, int n, int m) test de l'egalite de deux matrices A et B; elles doivent avoir ete normalisees au prealable pour que le test soit mathematiquement exact

Les parametres de la fonction :

int A[] : matrice int B[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice

Definition at line 285 of file matrice.c.

{
    int i;
    for (i = 0 ;i<= n*m;i++)
        if(value_ne(B[i],A[i]))
            return(false);
    return(true);
}

References B, and value_ne.

matrice_multiply()

void matrice_multiply	(	matrice	a,
		matrice	b,
		matrice	c,
		int	p,
		int	q,
		int	r
	)

void matrice_multiply(matrice a, matrice b, matrice c, int p, int q, int r): multiply rational matrix a by rational matrix b and store result in matrix c

 a is a (pxq) matrix, b a (qxr) and c a (pxr)

 c := a x b ;

Algorithm used is directly from definition, and space has to be provided for output matrix c by caller. Matrix c is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: p > 0; q > 0; r > 0; c != a; c != b; – aliasing between c and a or b – is not supported input

validate dimensions

simplified aliasing test

set denominator

use ordinary school book algorithm

Parameters

b	a is a (pxq) matrix, b a (qxr) and c a (pxr) c := a x b ; Algorithm used is directly from definition, and space has to be provided for output matrix c by caller. Matrix c is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: p > 0; q > 0; r > 0; c != a; c != b; – aliasing between c and a or b – is not supported input

Parameters

c	a is a (pxq) matrix, b a (qxr) and c a (pxr) c := a x b ; Algorithm used is directly from definition, and space has to be provided for output matrix c by caller. Matrix c is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: p > 0; q > 0; r > 0; c != a; c != b; – aliasing between c and a or b – is not supported input

Parameters

p	a is a (pxq) matrix, b a (qxr) and c a (pxr) c := a x b ; Algorithm used is directly from definition, and space has to be provided for output matrix c by caller. Matrix c is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: p > 0; q > 0; r > 0; c != a; c != b; – aliasing between c and a or b – is not supported output

Parameters

q	a is a (pxq) matrix, b a (qxr) and c a (pxr) c := a x b ; Algorithm used is directly from definition, and space has to be provided for output matrix c by caller. Matrix c is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: p > 0; q > 0; r > 0; c != a; c != b; – aliasing between c and a or b – is not supported input

Parameters

r	a is a (pxq) matrix, b a (qxr) and c a (pxr) c := a x b ; Algorithm used is directly from definition, and space has to be provided for output matrix c by caller. Matrix c is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: p > 0; q > 0; r > 0; c != a; c != b; – aliasing between c and a or b – is not supported input

Definition at line 82 of file matrice.c.

{
    int loop1,loop2,loop3;
    register Value i,va,vb;
 
    /* validate dimensions */
    assert(p > 0 && q > 0 && r > 0);
    /* simplified aliasing test */
    assert(c != a && c != b);
 
    /* set denominator */
    DENOMINATOR(c) = value_mult(DENOMINATOR(a),DENOMINATOR(b));
 
    /* use ordinary school book algorithm */
    for(loop1=1; loop1<=p; loop1++)
        for(loop2=1; loop2<=r; loop2++) {
            i = VALUE_ZERO;
            for(loop3=1; loop3<=q; loop3++) 
            {
                va = ACCESS(a,p,loop1,loop3);
                vb = ACCESS(b,q,loop3,loop2);
                value_addto(i,value_mult(va,vb));
            }
            ACCESS(c,p,loop1,loop2) = i;
        }
}

References ACCESS, assert, DENOMINATOR, loop1, value_addto, value_mult, and VALUE_ZERO.

Referenced by hyperplane(), matrice_general_inversion(), matrice_unimodulaire_inversion(), sc_image_computation(), and unimodular().

Here is the caller graph for this function:

matrice_normalize()

void matrice_normalize	(	matrice	a,
		int	n,
		int	m
	)

void matrice_normalize(matrice a, int n, int m)

 A rational matrix is stored as an integer one with one extra
 integer, the denominator for all the elements. To normalise the
 matrix in this sense means to reduce this denominator to the 
 smallest positive number possible. All elements are also reduced
 to their smallest possible value.

Precondition: DENOMINATOR(a)!=0 output

we must find the GCD of all elements of matrix

factor out

ensure denominator is positive

FI: this code is useless because pgcd()always return a positive integer, even if a is the null matrix; its denominator CANNOT be 0

Parameters

n	A rational matrix is stored as an integer one with one extra integer, the denominator for all the elements. To normalise the matrix in this sense means to reduce this denominator to the smallest positive number possible. All elements are also reduced to their smallest possible value. Precondition: DENOMINATOR(a)!=0 input
m	A rational matrix is stored as an integer one with one extra integer, the denominator for all the elements. To normalise the matrix in this sense means to reduce this denominator to the smallest positive number possible. All elements are also reduced to their smallest possible value. Precondition: DENOMINATOR(a)!=0 input

Definition at line 125 of file matrice.c.

{
    int loop1,loop2;
    Value factor;
 
    assert(value_notzero_p(DENOMINATOR(a)));
 
    /* we must find the GCD of all elements of matrix */
    factor = DENOMINATOR(a);
 
    for(loop1=1; loop1<=n; loop1++)
        for(loop2=1; loop2<=m; loop2++) 
            factor = pgcd(factor,ACCESS(a,n,loop1,loop2));
 
    /* factor out */
    if (value_notone_p(factor)) {
        for(loop1=1; loop1<=n; loop1++)
            for(loop2=1; loop2<=m; loop2++)
                value_division(ACCESS(a,n,loop1,loop2),factor);
        value_division(DENOMINATOR(a),factor);
    }
 
    /* ensure denominator is positive */
    /* FI: this code is useless because pgcd()always return a positive integer,
       even if a is the null matrix; its denominator CANNOT be 0 */
    assert(value_pos_p(DENOMINATOR(a)));
    /*
    if(DENOMINATOR(a) < 0) {
        DENOMINATOR(a) = DENOMINATOR(a)*-1;
        for(loop1=1; loop1<=n; loop1++)
            for(loop2=1; loop2<=m; loop2++)
                value_oppose(ACCESS(a,n,loop1,loop2));
    }*/
}

References ACCESS, assert, DENOMINATOR, loop1, pgcd, value_division, value_notone_p, value_notzero_p, and value_pos_p.

Referenced by average_probability_matrix(), make_tile_constraints(), and tile_membership().

Here is the caller graph for this function:

matrice_normalizec()

void matrice_normalizec	(	matrice	MAT,
		int	n,
		int	m
	)

void matrice_normalizec(matrice MAT, int n, int m): Normalisation des coefficients de la matrice MAT, i.e.

division des coefficients de la matrice MAT et de son denominateur par leur pgcd

La matrice est modifiee.

Les parametres de la fonction :

!int MAT[] : matrice de dimension (n,m) int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice

FI What an awful test! It should be an assert()

Parameters

MAT

AT

Definition at line 175 of file matrice.c.

{
    int i;
    Value a;
 
    /* FI What an awful test! It should be an assert() */
    if (n && m) {
        a = MAT[0];
        for (i = 1;(i<=n*m) && value_gt(a,VALUE_ONE);i++)
            a = pgcd(a,MAT[i]);
 
        if (value_gt(a,VALUE_ONE)) {
            for (i = 0;i<=n*m;i++)
                value_division(MAT[i],a);
        }
    }
}

References pgcd, value_division, value_gt, and VALUE_ONE.

matrice_nulle()

void matrice_nulle	(	matrice	Z,
		int	n,
		int	m
	)

void matrice_nulle(matrice Z, int n, int m): Initialisation de la matrice Z a la valeur matrice nulle

Post-condition:

QQ i dans [1..n] QQ j dans [1..n] Z(i,j) == 0

Les parametres de la fonction :

!int Z[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice

Definition at line 311 of file matrice.c.

{
    int i,j;
 
    for (i=1;i<=n;i++)
        for (j=1;j<=m;j++)
            ACCESS(Z,n,i,j)=VALUE_ZERO;
    DENOMINATOR(Z) = VALUE_ONE;
}

References ACCESS, DENOMINATOR, VALUE_ONE, and VALUE_ZERO.

Referenced by average_probability_matrix(), base_G_h1_unnull(), broadcast_conditions(), build_transfer_matrix(), contraintes_with_sym_cst_to_matrices(), loop_nest_to_tile(), loop_sc_to_matrices(), make_primal(), mat_perm_col(), mat_perm_lig(), matrice_diagonale_inversion(), matrice_hermite(), matrice_triangulaire_inversion(), partial_broadcast_coefficients(), pu_contraintes_to_matrices(), sc_image_computation(), sc_to_matrices(), sys_matrice_index(), and system_inversion_restrict().

Here is the caller graph for this function:

matrice_nulle_p()

bool matrice_nulle_p	(	matrice	Z,
		int	n,
		int	m
	)

bool matrice_nulle_p(matrice Z, int n, int m): test de nullite de la matrice Z

QQ i dans [1..n] QQ j dans [1..n] Z(i,j) == 0

Les parametres de la fonction :

int Z[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice

Definition at line 336 of file matrice.c.

{
    int i,j;
 
    for (i=1;i<=n;i++)
        for (j=1;j<=m;j++)
            if(value_notzero_p(ACCESS(Z,n,i,j)))
                return(false);
    return(true);
}

References ACCESS, and value_notzero_p.

matrice_soustraction_colonne()

void matrice_soustraction_colonne	(	matrice	MAT,
		int	n,
		int m	__attribute__(unused),
		int	c1,
		int	c2,
		Value	x
	)

void matrice_soustraction_colonne(matrice MAT,int n,int m,int c1,int c2,int x): Soustrait x fois la colonne c2 de la colonne c1 Precondition: n > 0; m > 0; 0 < c1, c2 < m; Effet: c1[0..n-1] = c1[0..n-1] - x*c2[0..n-1].

Les parametres de la fonction :

int MAT[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice int c1 : numero du colonne int c2 : numero du colonne int x :

Definition at line 523 of file matrice.c.

{
    int i;
    register Value p;
    for (i=1; i<=n; i++)
    {
        p = ACCESS(MAT,n,i,c2);
        value_product(p,x);
        value_substract(ACCESS(MAT,n,i,c1),p);
    }
}

References ACCESS, value_product, value_substract, and x.

Referenced by matrice_hermite(), matrice_smith(), and matrice_unimodulaire_triangulaire_inversion().

Here is the caller graph for this function:

matrice_soustraction_ligne()

void matrice_soustraction_ligne	(	matrice	MAT,
		int	n,
		int	m,
		int	r1,
		int	r2,
		Value	x
	)

void matrice_soustraction_ligne(matrice MAT,int n,int m,int r1,int r2,int x): Soustrait x fois la ligne r2 de la ligne r1 Precondition: n > 0; m > 0; 0 < r1, r2 < n; Effet: r1[0..m-1] = r1[0..m-1] - x*r2[0..m-1]

Les parametres de la fonction :

int MAT[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice int r1 : numero du ligne int r2 : numero du ligne int x :

Parameters

MAT	AT
r1	1
r2	2

Definition at line 554 of file matrice.c.

{
    int i;
    register Value p;
    for (i=1; i<=m; i++)
    {
        p = ACCESS(MAT,n,r2,i);
        value_product(p,x);
        value_substract(ACCESS(MAT,n,r1,i),p);
    }
}

References ACCESS, value_product, value_substract, and x.

Referenced by matrice_smith().

Here is the caller graph for this function:

matrice_substract()

void matrice_substract	(	matrice	a,
		matrice	b,
		matrice	c,
		int	n,
		int	m
	)

void matrice_substract(matrice a, matrice b, matrice c, int n, int m): substract rational matrix c from rational matrix b and store result in matrix a

 a is a (nxm) matrix, b a (nxm) and c a (nxm)

 a = b - c ;

Algorithm used is directly from definition, and space has to be provided for output matrix a by caller. Matrix a is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: n > 0; m > 0; Note: aliasing between a and b or c is supported input

denominators of b, c

ppcm of b,c

precondition

Parameters

b	a is a (nxm) matrix, b a (nxm) and c a (nxm) a = b - c ; Algorithm used is directly from definition, and space has to be provided for output matrix a by caller. Matrix a is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: n > 0; m > 0; Note: aliasing between a and b or c is supported output

Parameters

n	a is a (nxm) matrix, b a (nxm) and c a (nxm) a = b - c ; Algorithm used is directly from definition, and space has to be provided for output matrix a by caller. Matrix a is not necessarily normalized: its denominator may divide all its elements (see matrice_normalize()).

Precondition: n > 0; m > 0; Note: aliasing between a and b or c is supported input

Definition at line 468 of file matrice.c.

{
    register Value d1,d2;   /* denominators of b, c */
    register Value lcm;     /* ppcm of b,c */
    int i,j;
 
    /* precondition */
    assert(n>0 && m>0);
    assert(value_pos_p(DENOMINATOR(b)));
    assert(value_pos_p(DENOMINATOR(c)));
 
    d1 = DENOMINATOR(b);
    d2 = DENOMINATOR(c);
    if (d1 == d2){
        for (i=1; i<=n; i++)
            for (j=1; j<=m; j++)
                ACCESS(a,n,i,j) = value_minus(ACCESS(b,n,i,j),
                                              ACCESS(c,n,i,j));
        DENOMINATOR(a) = d1;
    }
    else{
        register Value v1,v2;
        lcm = ppcm(d1,d2);
        DENOMINATOR(a) = lcm;
        d1 = value_div(lcm,d1);
        d2 = value_div(lcm,d2);
        for (i=1; i<=n; i++)
            for (j=1; j<=m; j++) 
            {
                v1 = ACCESS(b,n,i,j);
                value_product(v1, d1);
                v2 = ACCESS(c,n,i,j);
                value_product(v2, d2);
                ACCESS(a,n,i,j) = value_minus(v1,v2);
            }
    }
}

References ACCESS, assert, DENOMINATOR, ppcm(), value_div, value_minus, value_pos_p, and value_product.

Referenced by unstructured_to_complexity().

Here is the call graph for this function:

Here is the caller graph for this function:

matrice_swap_columns()

void matrice_swap_columns	(	matrice	matrix,
		int	n,
		int	m,
		int	c1,
		int	c2
	)

void matrice_swap_columns(matrice matrix, int n, int m, int c1, int c2): exchange columns c1,c2 of an (nxm) rational matrix

 Precondition:      n > 0; m > 0; 0 < c1 <= m; 0 < c2 <= m; 

column numbers

validation step

Parameters

matrix	atrix
n	Precondition: n > 0; m > 0; 0 < c1 <= m; 0 < c2 <= m; input and output matrix
m	Precondition: n > 0; m > 0; 0 < c1 <= m; 0 < c2 <= m; number of rows
c1	Precondition: n > 0; m > 0; 0 < c1 <= m; 0 < c2 <= m; number of columns
c2	2

Definition at line 200 of file matrice.c.

{
    int loop1;
    register Value temp;
 
    /* validation step */
    /*
     * if ((n < 1) || (m < 1))   return(-208);
     * if ((c1 > m) || (c2 > m)) return(-209);
     */
    assert(n > 0 && m > 0);
    assert(0 < c1 && c1 <= m);
    assert(0 < c2 && c2 <= m);
 
    for(loop1=1; loop1<=n; loop1++) {
        temp = ACCESS(matrix,n,loop1,c1);
        ACCESS(matrix,n,loop1,c1) = ACCESS(matrix,n,loop1,c2);
        ACCESS(matrix,n,loop1,c2) = temp;
    }
}       

References ACCESS, assert, and loop1.

Referenced by matrice_hermite(), and matrice_smith().

Here is the caller graph for this function:

matrice_swap_rows()

void matrice_swap_rows	(	matrice	a,
		int	n,
		int	m,
		int	r1,
		int	r2
	)

void matrice_swap_rows(matrice a, int n, int m, int r1, int r2): exchange rows r1 and r2 of an (nxm) rational matrix a

Precondition: n > 0; m > 0; 1 <= r1 <= n; 1 <= r2 <= n row numbers

validation

Parameters

n	Precondition: n > 0; m > 0; 1 <= r1 <= n; 1 <= r2 <= n input and output matrix
m	Precondition: n > 0; m > 0; 1 <= r1 <= n; 1 <= r2 <= n number of columns
r1	Precondition: n > 0; m > 0; 1 <= r1 <= n; 1 <= r2 <= n number of rows
r2	2

Definition at line 230 of file matrice.c.

{
    int loop1;
    register Value temp;
 
    /* validation */
    assert(n > 0);
    assert(m > 0);
    assert(0 < r1 && r1 <= n);
    assert(0 < r2 && r2 <= n);
 
    for(loop1=1; loop1<=m; loop1++) {
        temp = ACCESS(a,n,r1,loop1);
        ACCESS(a,n,r1,loop1) = ACCESS(a,n,r2,loop1);
        ACCESS(a,n,r2,loop1) = temp;
    }
}

References ACCESS, assert, and loop1.

Referenced by matrice_hermite(), matrice_smith(), and scanning_base_hyperplane().

Here is the caller graph for this function:

matrice_transpose()

void matrice_transpose	(	matrice	a,
		matrice	a_t,
		int	n,
		int	m
	)

package matrice

matrice.c

void matrice_transpose(matrice a, matrice a_t, int n, int m): transpose an (nxm) rational matrix a into a (mxn) rational matrix a_t

    t

a_t := a ;

verification step

copy from a to a_t

Parameters

a_t

_t

Definition at line 48 of file matrice.c.

{
    int loop1,loop2;
 
    /* verification step */
    assert(n >= 0 && m >= 0);
 
    /* copy from a to a_t */
    DENOMINATOR(a_t) = DENOMINATOR(a);
    for(loop1=1; loop1<=n; loop1++)
        for(loop2=1; loop2<=m; loop2++) 
            ACCESS(a_t,m,loop2,loop1) = ACCESS(a,n,loop1,loop2);
}

References ACCESS, assert, DENOMINATOR, and loop1.

Referenced by base_G_h1_unnull(), broadcast_conditions(), make_primal(), partial_broadcast_coefficients(), and system_inversion_restrict().

Here is the caller graph for this function:

matrice_triangulaire_p()

bool matrice_triangulaire_p	(	matrice	Z,
		int	n,
		int	m,
		bool	inferieure
	)

bool matrice_triangulaire_p(matrice Z, int n, int m, bool inferieure): test de triangularite de la matrice Z

si inferieure == true QQ i dans [1..n] QQ j dans [i+1..m] Z(i,j) == 0

si inferieure == false (triangulaire superieure) QQ i dans [1..n] QQ j dans [1..i-1] Z(i,j) == 0

Les parametres de la fonction :

int Z[] : matrice int n : nombre de lignes de la matrice int m : nombre de colonnes de la matrice

Parameters

inferieure

nferieure

Definition at line 394 of file matrice.c.

{
    int i,j;
 
    for (i=1; i <= n; i++)
        if(inferieure) {
            for (j=i+1; j <= m; j++)
                if(value_notzero_p(ACCESS(Z,n,i,j)))
                    return(false);
        }
        else
            for (j=1; j <= i-1; j++)
                if(value_notzero_p(ACCESS(Z,n,i,j)))
                    return(false);
    return(true);
}

References ACCESS, and value_notzero_p.

Referenced by matrice_triangulaire_inversion(), and matrice_triangulaire_unimodulaire_p().

Here is the caller graph for this function:

matrice_triangulaire_unimodulaire_p()

bool matrice_triangulaire_unimodulaire_p	(	matrice	Z,
		int	n,
		bool	inferieure
	)

bool matrice_triangulaire_unimodulaire_p(matrice Z, int n, bool inferieure) test de la triangulaire et unimodulaire de la matrice Z.

si inferieure == true QQ i dans [1..n] QQ j dans [i+1..n] Z(i,j) == 0 i dans [1..n] Z(i,i) == 1

si inferieure == false (triangulaire superieure) QQ i dans [1..n] QQ j dans [1..i-1] Z(i,j) == 0 i dans [1..n] Z(i,i) == 1

les parametres de la fonction : matrice Z : la matrice entre int n : la dimension de la martice caree

Parameters

inferieure

nferieure

Definition at line 434 of file matrice.c.

{
    bool triangulaire;
    int i;
    triangulaire = matrice_triangulaire_p(Z,n,n,inferieure);
    if (triangulaire == false)
        return(false);
    else{
        for(i=1; i<=n; i++)
            if (value_notone_p(ACCESS(Z,n,i,i)))
                return(false);
        return(true);
    }
}           

References ACCESS, matrice_triangulaire_p(), and value_notone_p.

Referenced by matrice_unimodulaire_inversion(), and matrice_unimodulaire_triangulaire_inversion().

Here is the call graph for this function:

Here is the caller graph for this function: