Fonctions relatives aux tableaux
|
|
Ces fonctions s'appliquent à des
tableaux de rang quelconque et fournissent un résultat (un scalaire
ou un tableau) du même type que les éléments du
tableau.
Certaines d'entre elles peuvent comporter un argument
optionnel dim et mask.
L'argument scalaire dim
(un entier positif) sert à indiquer une dimension du tableau,
l'argument d'un type logique mask serve de "masque" et
doit être compatible avec le premier argument de la fonction.
dot_product (vector_a, vector_b)
| produit scalaire | catégorie: T | arguments: i,i arguments: r,r arguments: z,z arguments: l,l |
résultat: i résultat: r résultat: z résultat: l |
Renvoie le produit scalaire pour les arguments numériques. Elle peut porter sur des tableaux de type logique et renvoie dans ce cas-là la valeur de la somme logique du produit logique des arguments. Les deux arguments vector_a et vector_b doivent être des tableaux de rang 1 de même taille, de types tous les deux numérique (mais pas obligatoirement le même), ou tous deux logiques. Le résultat est un scalaire numérique si les vecteurs sont numériques (du type identique au type de résultat de l'opération * entre eux). Le résultat est de type logical pour les arguments logiques.
Si vector_a est de type entier ou réel,
on obtient la valeur de l'expression
sum (vector_a * vector_b),
avec le type correspondant à cette expression.
Si vector_a est de type complexe, on obtient la
valeur de l'expression:
sum (conjg (vector_a) * vector_b),
avec le type correspondant à cette expression.
Si vector_a et vector_b sont tous deux
de type logique, on obtient la valeur logique de l'expression:
any
(vector_a .and. vector_b).
Exemples:
| matrice transposée | catégorie: T | arguments: * | résultat: * |
Renvoie la transposée de la matrice matrix (un tableau de rang 2) de type quelconque. Le résultat est un tableau de même rang et type que matrix. Le profil du tableau résultat est égal à (/size(matrix,2), size(matrix,1) /).
Exemples:
| produit matriciel | catégorie: T | arguments: i,i arguments: r,r arguments: z,z arguments: l,l |
résultat: i résultat: r résultat: z résultat: l |
Renvoie le produit de deux matrices matrix_a et matrix_b, ou le produit d'un vecteur (ligne) par une matrice ou le produit d'une matrice par un vecteur (colonne). Les dimensions des tableaux (au des vecteurs) sont soumises aux contraintes classiques en algèbre linéaire. La fonction matmul peut porter sur des tableaux de types tous deux numériques (mais pas nécessairement le même), ou tous deux logiques.
Dans le cas de deux matrices de rang 2 et de profils (n,m) et (m,k), le résultat est de rang 2 et de profil (n,k) et son élément (i,j) vaut: dot_product(matrix_a(i,:),matrix_b(:,j)).
Lorsque matrix_a est de rang 1 et correspond à un vecteur-ligne(1:m), le résultat est aussi de rang 1 et correspond au vecteur-ligne (1:k) dont élément j vaut: dot_product(matrix_a,matrix_b(:,j)).
Lorsque matrix_b est un vecteur-colonne(1:k), le résultat est le vecteur-colonne (1:n) dont élément i vaut: dot_product(matrix_a(i,:),matrix_b).
Si matrix_a est complexe, le résultat s'obtient en appliquant le produit scalaire à conjg(matrix_a).
Dans le cas d'arguments de type logique, on obtient le résultat logique (dont la valeur correspond à la fonction dot_product appliquée aux arguments logiques).
Exemples:
Argument optionnel dim
L'argument optionnel de type entier dim permet de préciser la dimension. Dans ce cas, l'opération correspondante est appliquée à toutes les sections du tableau array que l'on peut obtenir en fixant tous les indices, hormis celui relatif à la dimension spécifiée par dim. L'ensemble de ces résultats forme un tableau de rang inférieur d'une unité à celui de array.
Argument optionnel mask
Le paramètre optionnel mask
est une expression logique compatible avec array (correspondant à
un tableau de type logique ayant le même rang et le même
profil que array). Il peut servir à filtrer les éléments
du tableau sur lesquels l'opération s'applique. Dans ce cas l'opération
correspondante n'est appliquée qu'aux éléments du
tableau array pour lesquels l'élément correspondant
de mask a la valeur vrai.
| somme des éléments | catégorie: T | arguments: i[,i][,l] arguments: r[,i][,l] arguments: z[,i][,l] |
résultat: i résultat: r résultat: z |
Renvoie la somme des valeurs des éléments du tableau array. Le résultat est du même type que les éléments de array qui peuvent être de type entier, réel ou complexe. Si le tableau array est de taille nulle, le résultat vaut 0.
Pour un tableau: integer, dimension (5, 8, 13, 25) :: tab l'expression sum (tab, dim = 2) est un tableau de rang 3, de profil (5, 13, 25); un élément de rang i, j, k ayant pour valeur sum (tab (i,:,j,k)).
product (array [,dim] [,mask])
| produit des éléments | catégorie: T | arguments: i[,i][,l] arguments: r[,i][,l] arguments: z[,i][,l] |
résultat: i résultat: r résultat: z |
Renvoie le produit des valeurs des éléments du tableau array ( après le filtrage par dim et / ou mask , s'il y a lieu). Le résultat est du même type que les éléments de array qui peuvent être de type entier, réel ou complexe. Si le tableau array est de taille nulle, le résultat vaut 1.
maxval (array [,dim] [, mask])
| valeur maximale | catégorie: T | arguments: i[,i][,l] arguments: r[,i][,l] |
résultat: i résultat: r |
Renvoie la plus grande valeur du tableau array (après le filtrage par dim et / ou mask , s'il y a lieu). Le résultat est du même type que les éléments de array qui peuvent être de type entier ou réel. Si le tableau array est de taille nulle, le résultat est égal à la valeur la plus petite représentable dans le type concerné.
| valeur minimale | catégorie: T | arguments: i[,i][,l] arguments: r[,i][,l] |
résultat: i résultat: r |
Renvoie la plus petite valeur du tableau array ( après le filtrage par dim et / ou mask , s'il y a lieu) Le résultat est du même type que les éléments de array qui peuvent être de type entier ou réel. Si le tableau array est de taille nulle, le résultat est égal à la plus grande valeur représentable dans le type concerné.
Exemples:
| produit logique | catégorie: T | arguments: l[,i] | résultat: l |
Renvoie le produit logique des éléments du tableau mask. On obtient la valeur vrai si tous les éléments du tableau logique mask ont la valeur vrai (ou si mask est de taille zéro).
| somme logique | catégorie: T | arguments: l[,i] | résultat: l |
Renvoie la somme logique des éléments du tableau mask. On obtient la valeur vrai si l'un au moins des éléments du tableau logique mask a la valeur vrai, et la valeur faux dans le cas contraire (aucun élément n'a la valeur vrai ou tableau est de taille nulle).
| nombre d'éléments vrais | catégorie: T | arguments: l[,i] | résultat: i |
Renvoie le nombre d'éléments du tableau logique mask ayant la valeur vrai. Le résultat est un entier standard.
Exemples:
| position d'un élément maximal | catégorie: T | arguments: i[,l] arguments: r[,l] |
résultat: i résultat: i |
Renvoie les coordonnes relatives d'un élément maximal parmi les éléments du tableau array entier ou réel. Le résultat est un tableau de rang 1 d'entiers (standards) dont la taille est égale au rang de array, contenant les indices relatifs à la plus grande valeur de array. Si elle apparaît plusieurs fois, c'est la position du premier, au sens de l'arrangement en mémoire, qui est fournie. Le paramètre optionnel mask, compatible avec array, d'un type logique, permet de limiter la recherche aux seuls éléments de array correspondant aux valeurs vrai de mask. Si array est vide, ou si mask=.false., le résultat de la procédure est indéterminé. Les valeurs maximales sont données par la fonction maxval.
| position d'un élément minimal | catégorie: T | arguments: i[,l] arguments: r[,l] |
résultat: i résultat: i |
Renvoie les coordonnes relatives d'un élément minimal parmi les éléments du tableau array entier ou réel. Le résultat est un tableau de rang 1 d'entiers (standards) dont la taille est égale au rang de array, contenant les indices relatifs à la plus petite valeur de array . Si elle apparaît plusieurs fois, c'est la position du premier, au sens de l'arrangement en mémoire, qui est fournie. Si mask est précisé (il doit être un tableau de type logical de même profil que array ), il est appliqué comme filtre à la recherche. Seuls les éléments de array pour lesquels l'élément correspondant de mask est vrai sont considérés. Si array est vide, ou si mask=.false., le résultat de la procédure est indéterminé. Les valeurs minimales sont données par la fonction minval.
Exemples:
| l'état d'un tableau (alloué ou non) | catégorie: A | arguments: * | résultat: l |
Renvoie la valeur logique vrai si le tableau array est actuellement alloué et la valeur faux dans le cas contraire. Le tableau array doit être déclaré avec l'attribut allocated.
| borne inférieure | catégorie: A | arguments: *[,i] | résultat: i |
Renvoie les bornes inférieures du tableau array sous forme d'un vecteur d'entiers (standards) contenant des bornes successives suivant toutes ses dimensions. La taille du vecteur est égale au rang de array. Si le paramètre entier dim est présent, la procédure fournit la borne inférieure (entier standard) du tableau array, suivant sa dimension dim.
| borne supérieure | catégorie: A | arguments: *[,i] | résultat: i |
Renvoie les bornes supérieures du tableau array sous forme d'un vecteur d'entiers (standards) contenant des bornes successives suivant toutes ses dimensions. La taille du vecteur est égale au rang de array. Si le paramètre entier dim est présent, la procédure fournit la borne supérieure (entier standard) du tableau array, suivant sa dimension dim.
| profil d'un tableau | catégorie: A | arguments: * | résultat: i |
Renvoie le profil du tableau source sous forme d'un tableau d'entiers (standards) de rang 1. Si source est un scalaire, on obtient un tableau de taille 0 (un vecteur vide).
| taille d'un tableau | catégorie: A | arguments: *[,i] | résultat: i |
Renvoie la taille du tableau array, égale à product(shape(array)). Si dim est présent, la fonction renvoie l'étendue de array pour la dimension indiquée (égale à ubound(array,dim)-lbound(array,dim)+1 ).
Exemples:
real, dimension(-5:4,0:7) :: array
...
lbound(array) vaut (/ -5, 0 /)
lbound(array,1) vaut -5
ubound(array) vaut (/ 4, 7 /)
ubound(array,2) vaut 7
shape(array) vaut (/ 10, 8 /)
size(array) vaut 80
size(array,2) vaut 8
real, allocatable :: mat(:,:) ! mat est
un tableau dynamique
read *, n,m
...
print *, allocated(mat) !
affiche .false. car le tableau mat n'est pas alloué actuellement
allocate( mat(n,m) )
print *, allocated(mat) ! affiche .true. car
le tableau mat est alloué actuellement
deallocate (mat) !
print *,
allocated(mat) ! affiche .false. car le tableau mat n'est plus alloué
merge (tsource, fsource, mask)
| fusion de deux tableaux | catégorie: D | arguments: *,*,l | résultat: * |
Renvoie la valeur du paramètre tsource si mask est vrai, et la valeur de fsource sinon. Les arguments tsource et fsource doivent être d'un même type (un type quelconque) ou de la même longueur (pour les chaînes de caractères). L'argument mask est de type logique. Les trois arguments doivent être tous les trois soit des scalaires, soit des tableaux de même profil. Cette fonction peut servir à représenter une définition conditionnelle utilisable au sein d'une expression.
La fonction merge peut être utilisée à construire, à partir de deux tableaux tsource, fsource, un nouveau tableau par un prélèvement des valeurs dans le premier tableau ou dans le second tableau, suivant la valeur de la condition exprimée dans mask. Chaque élément du résultat a pour valeur soit celle de l'élément correspondant de tsource si l'élément correspondant de mask a la valeur vrai, soit l'élément correspondant de fsource dans le cas contraire.
La fonction merge('a','z',n>0) renvoie le caractère 'a' si n est supérieur à 0, et le caractère 'z' sinon.
Exemples:
| linéarisation et filtrage | catégorie: T | arguments: *,l[,*] | résultat: * |
Construit un vecteur des éléments du tableau array correspondant à une valeur vrai dans mask compatible avec array) pris selon leur ordre naturel, complétés le cas échéant par les éléments finaux du vecteur vector. Lorsque array est un tableau de rang supérieur à 1, ses éléments sont considérés suivant l'ordre dans lequel ils sont rangés en mémoire (le premier indice variant donc le plus rapidement). Le résultat est du même sous-type (quelconque) que array (et que vector s'il y a lieu). En l'absence de vector la taille du résultat est égale à count(mask) ou celle de array si mask est scalaire .true.. La fonction pack permet d'extraire, certaines valeurs d'un tableau array de rang quelconque pour lesquels l'élément correspondant de mask a la valeur vrai.
Si vector est présent, et sa taille est égale à n, le résultat est vecteur de n éléments avec t premiers éléments provenant de array où t= count(mask), complétés éventuellement par les dernières valeurs (de même indice) de vector c'est a dire par vector(t+1:n). Dans ce cas, vector doit donc comporter au moins autant d'éléments qu'il y a de valeurs vrai dans mask (il faut, que n>=t).
Exemples:
| inverse de la fonction pack | catégorie: T | arguments: *,l[,*] | résultat: * |
Construit un tableau de rang supérieur à 1, (dont le profil est fixe par mask) en incorporant à certains emplacements des valeurs provenant d'un tableau vector de rang 1 (de type quelconque) et du tableau field (un tableau de même profil que mask ou un scalaire). La taille de vector doit être au moins égale à count(mask). Le résultat est un tableau de même profil que mask, du sous-type commun à vector et field.
Ses éléments sont remplis suivant l'ordre naturel de rangement en mémoire en considérant l'élément correspondant de mask. S'il est vrai, on prend une valeur provenant de vector (ici, il n'y a plus de correspondance d'indice, on prélève la valeur suivante à chaque fois qu'on en a besoin). S'il est faux, il s'agit de la valeur correspondante de field lorsque cet argument est un tableau (ou de la valeur field lorsque cet argument est un scalaire).
Exemples:
reshape (source, shape [,pad] [,order])
| restructuration | catégorie: T | arguments: *,i[,*][,i] | résultat: * |
Construit un tableau à plusieurs dimensions dont les éléments sont ceux de source (complété, s'il y a lieu, de pad) et dont le profil est défini par le vecteur shape. Le type (quelconque) du résultat est celui de source (et de pad le cas échéant). Le tableau shape est un tableau d'entiers non négatifs (standards) de rang 1, dont la taille doit être constante.
Si pad est présent (un tableau de même type que source), ses valeurs sont utilisées (dans leur ordre naturel) et, si nécessaire, plusieurs fois, pour compléter le résultat, si la taille définie par shape dépasse celle de source.
Si order est présent (un vecteur d'entiers de même taille que shape) les éléments de source (définis dans l'ordre usuel des indices) seront présentés dans le résultat dans l'ordre indiqué par les indices figurant dans order. Si, en plus, pad est présent, ses valeurs seront utilisées (éventuellement plusieurs fois) pour compléter le résultat, si sa taille dépasse celle de source.
| duplication de source | catégorie: T | arguments: *,i,i | résultat: * |
Construit un nouveau tableau en dupliquant ncopies fois les valeurs d'un tableau donné source suivant une nouvelle dimension (spécifiée par le numéro dim). L'argument source est un scalaire ou un tableau de rang n<6 (de type quelconque). Le résultat renvoyé est un tableau de rang égal à celui de source augmenté de 1 (c'est-à-dire n+1), et de même type que source. Son profil se déduit de celui de source en lui ajoutant l'étendue ncopies pour la dimension de rang dim. Si source est scalaire (n=0), le résultat est le vecteur (/ ( source, i=1,ncopies ) /).
Si source est un vecteur, on obtient une matrice formée de ncopies lignes égales à source si dim=1, de ncopies colonnes égales à source si dim=2.
Exemples:
| décalage circulaire | catégorie: T | arguments: *,i[,i] | résultat: * |
Sert à effectuer des permutations circulaires de sections d'un
tableau de type, rang et profil quelconques. Le résultat est de même
type et de même profil que array. L'argument shift,
d'un type entier, doit être scalaire si array est de
rang 1 ou de rang n-1, si n est celui de array (avec le
profil 
où
représente
le profil de array et d=dim. L'argument dim est un
entier compris entre 1 et n. S'il est absent, sa valeur par défaut
vaut 1.
Lorsque shift est un scalaire, le résultat est le tableau obtenu en décalant circulairement shift fois chaque section de rang 1 s'étendant suivant la dimension indiquée par dim. Le décalage circulaire se fait dans le sens des indices croissants si shift>0, dans le sens des indices décroissants si shift<0.
Lorsque shift est un tableau, il doit être de même profil que array privé de sa dimension dim et il fournit les décalages à appliquer à chacune des sections de rang 1 définies précédemment. Dans le cas ou array est une matrice, on décale les lignes de array si dim=1, ses colonnes si dim=2. Le décalage est le même pour toutes les lignes ou colonnes respectivement, si shift est scalaire. Si shift est un vecteur, le décalage est spécifique à chaque colonne (dim=1) ou ligne (dim=2).
eoshift (array, shift [,boundary] [,dim])
| décalage avec expulsion | catégorie: T | arguments: *,i[,*][,i] | résultat: * |
Analogue à cshift, sauf que le décalage n'est plus circulaire; les valeurs manquantes sont remplacées soit par des zéros si boundary n'est pas spécifié, soit par celles précisées par boundary qui doit alors être de même type (variante comprise) et de même profil que array. Si boundary est omis, sa valeur par défaut est le scalaire élément neutre de la somme pour son type, ou une chaîne de len(array) espaces pour le type caractère.
Si boundary est scalaire, sa valeur est attribuée à toutes les valeurs manquantes. Si boundary est un tableau, il doit avoir le même profil que shift (c'est-à-dire celui de array privé de sa dimension dim) et il fournit les valeurs remplaçantes pour chaque décalage.
Exemples:
transfer (source, mold [,size])
| transfert interne | catégorie: T | arguments: *,*[,i] | résultat: * |
Renvoie une valeur du type de mold en utilisant la représentation interne de source. Cette fonction sert à effectuer des transferts d'information, sans tenir compte des types des objets concernés. Elle fournit un résultat formé du "motif binaire" contenu dans source mais ayant le type indiqué par mold (dont la valeur n'intervient pas et peut être même indéterminée ). Le résultat est un scalaire (du type de mold) si le paramètre size est absent et si mold est scalaire. Le résultat est un vecteur d'éléments du type de mold, si mold est un tableau (de taille size si ce paramètre est spécifié ou de la taille de source si size n'est pas spécifié). S'il n'y a pas suffisamment de valeurs dans source pour remplir le résultat, les valeurs absentes sont indéterminées. S'il y en a trop, il y aura de la troncature et seules les premières valeurs de source sont utilisées.
Exemples:
integer :: i
real
:: r
transfer (1,r) vaut
1.4012985E-45
transfer (2,r)
vaut 2.8025969E-45
transfer
(1.0,i) vaut 1065353216
transfer
(2.0,i) vaut 1073741824
transfer
((2.000000,-1.000000), i) vaut 1073741824
transfer
((2.000000,-1.000000), r) vaut 2.0
Retour à la table des matières