Section courante

A propos

Section administrative du site

Les fonctions standards

Les fonctions sont appelées en indiquant leur nom suivi d'une liste entre parenthèses de leurs paramètres. Par exemple, sqrt(a) calcule la racine carrée de son paramètre «a». Les parenthèses sont obligatoires, qu'elles contiennent des paramètres ou non. Les fonctions peuvent prendre plusieurs nombres et types de paramètres.

Mathématiques de base

Fonction :

abs ( x )

La fonction abs renvoie la valeur absolue de son paramètre numérique. «Valeur absolue» est synonyme de «magnitude» pour les types complexes. Si x n'est pas scalaire, chaque élément est remplacé par sa valeur absolue.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

acos ( x )

La fonction acos renvoie l'arc cosinus de son argument numérique. Si son paramètre est complexe ou a une magnitude supérieure à un, alors le résultat est complexe. Sinon, le résultat est réel. Si x n'est pas scalaire, chaque élément est remplacé par son arc cosinus.

Le paramètre x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

acosh ( x )

La fonction acosh renvoie l'arc cosinus hyperbolique de son argument numérique. Si son paramètre est complexe ou inférieur à 1,0, le résultat est complexe. Sinon, le résultat est réel. Si x n'est pas scalaire, chaque élément est remplacé par son arc cosinus hyperbolique.

Le paramètre x doit être un scalaire numérique, un vecteur ou une matrice. Notez que acosh(0) n'est pas nul, donc si acosh est appliqué à un vecteur ou une matrice clairsemée, alors un tableau dense est le résultat.

Fonction :

arg ( z )

La fonction arg renvoie le paramètre (angle de phase) de son paramètre numérique.

Voir aussi abs.

Fonction :

asin ( x )

La fonction asin renvoie l'arc sinus de son paramètre numérique. Si son paramètre est complexe ou a une magnitude supérieure à un, alors le résultat est complexe. Sinon, le résultat est réel. Si x n'est pas scalaire, chaque élément est remplacé par son arc sinus.

Le paramètre x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

asinh ( x )

La fonction asinh renvoie l'arc sinus hyperbolique de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son arc sinus hyperbolique.

Le paramètre x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

atan ( x )

La fonction atan renvoie l'arc tangente de son paramètre numérique. Si son paramètre est complexe, le résultat est complexe. Sinon, le résultat est réel. Si x n'est pas scalaire, chaque élément est remplacé par son arc tangente.

Le paramètre x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

atanh ( x )

La fonction atanh renvoie l'arc tangente hyperbolique de son paramètre numérique. Si son paramètre est complexe ou a une magnitude supérieure à 1,0, alors le résultat est complexe. Sinon, le résultat est réel. Si x n'est pas scalaire, chaque élément est remplacé par son arc tangente hyperbolique.

Le paramètre x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

atan2 ( y; x )

La fonction atan2 calcule un angle correspondant à y et x, les longueurs des côtés opposés et adjacents. Elle est similaire à atan(y/x), mais avec les différences suivantes :

Les paramètres doivent être des scalaires, des vecteurs ou des matrices, de type entier ou réel.

Fonction :

ceil ( x )

La fonction ceil renvoie le plafond de son paramètre numérique. Le plafond de x est le plus petit entier n'étant pas inférieur à x. Si x est complexe, le plafond s'applique à la fois aux parties réelles et imaginaires. Si x n'est pas scalaire, chaque élément est remplacé par son plafond. Le type de x n'est pas modifié par ceil.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

conj ( x )

La fonction conj renvoie le conjugué complexe de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son conjugué complexe.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

cos ( x )

La fonction cos renvoie le cosinus de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son cosinus.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

cosh ( x )

La fonction cosh renvoie le cosinus hyperbolique de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son cosinus hyperbolique.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

erf ( x )

La fonction erf renvoie la fonction d'erreur de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par le résultat de sa fonction d'erreur.

La fonction d'erreur est définie comme 2/sqrt(pi) fois l'intégrale de 0 à x de exp(-t^2) dt. Parmi ses propriétés utiles, la fonction d'erreur est deux fois l'intégrale de la distribution gaussienne avec une moyenne de 0 et une variance de 1/2.

Les paramètres complexes ne sont pas encore implémentés.

Fonction :

erfc ( x )

La fonction erfc renvoie la fonction d'erreur complémentaire de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par le résultat de sa fonction d'erreur complémentaire.

La fonction d'erreur complémentaire erfc(x) est simplement 1-erf(c), mais elle est calculée de manière à éviter les erreurs d'arrondi lorsque x est grand.

Les paramètres complexes ne sont pas encore implémentés.

Fonction :

exp ( x )

La fonction exp renvoie l'exponentielle de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son exponentielle.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

floor ( x )

La fonction floor renvoie le plancher de son argument numérique. Le plancher de x est le plus grand entier n'étant pas supérieur à x. Si x est complexe, le plancher s'applique à la fois aux parties réelles et imaginaires. Si x n'est pas scalaire, chaque élément est remplacé par son plancher. Le type de x n'est pas modifié par floor.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

gcd ( x )

Cette fonction calcule le plus grand diviseur commun (PGCD) des éléments de son argument vecteur. L'entrée est arrondie au type entier. La valeur de retour scalaire est le PGCD. Son membre «facteurs» contient un vecteur d'entiers tel que gcd(x).factors*x soit égal à gcd(x).

Voir aussi lcm et primef.

Fonction :

imag ( x )

La fonction imag renvoie la partie imaginaire de son argument numérique. Si x n'est pas scalaire, chaque élément est remplacé par sa partie imaginaire. La valeur renvoyée par imag est de type réel.

Voir aussi real.

Fonction :

integer ( x )

La fonction entière convertit la partie réelle de son argument numérique en type entier, en l'arrondissant si nécessaire.

Voir aussi round.

Fonction :

lcm ( x )

Cette fonction calcule le plus petit multiple commun (LCM) des éléments de son argument vectoriel. L'entrée est arrondie au type entier. La valeur de retour scalaire est le LCM.

Voir aussi gcd et primef.

Fonction :

log ( x )

La fonction log renvoie le logarithme naturel de son argument numérique. Si x n'est pas scalaire, chaque élément est remplacé par son logarithme.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

log10 ( x )

La fonction log10 renvoie le logarithme en base 10 de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son logarithme en base 10.

x doit être un scalaire numérique, un vecteur ou une matrice.

Fonction :

primef ( n )

Cette fonction calcule les facteurs premiers de son paramètre scalaire, les renvoyant sous forme d'éléments d'un vecteur entier. Le paramètre n est arrondi à l'entier, si nécessaire. Si le paramètre est inférieur à 2, un vecteur de longueur nulle est renvoyé.

Voir aussi pgcd, lcm et primes.

Fonction :

primes ( n )

Cette fonction génère un vecteur de nombres premiers inférieurs ou égaux au paramètre scalaire. Le paramètre n est arrondi à un entier, si nécessaire. Si le paramètre est inférieur à 2, un vecteur de longueur nulle est renvoyé.

Voir aussi pgcd, lcm et primes.

Fonction :

real ( x )

Cette fonction renvoie la partie réelle de x. La valeur renvoyée par real est de type real.

Voir aussi imag.

Fonction :

round ( x )

La fonction round arrondit son paramètre numérique au nombre entier le plus proche. Si x est complexe, les parties réelles et imaginaires sont arrondies. Si x n'est pas scalaire, chaque élément est arrondi. Le type de x n'est pas modifié par round.

Si Algae a été compilé pour utiliser la fonction rint(3m) du système, alors les paramètres avec une partie fractionnaire d'exactement 1/2 sont arrondis au nombre entier pair le plus proche. Sinon, ces paramètres sont arrondis vers +l'infini.

Voir aussi integer.

Fonction :

sin ( x )

La fonction sin renvoie le sinus de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son sinus.

Fonction :

sinh ( x )

La fonction sinh renvoie le sinus hyperbolique de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par son sinus hyperbolique.

Fonction :

sqrt ( x )

La fonction sqrt renvoie la racine carrée de son argument numérique. Si x est complexe ou négatif, le résultat est complexe. Sinon, le résultat est réel. Si x n'est pas scalaire, chaque élément est remplacé par sa racine carrée.

Fonction :

tan ( x )

La fonction tan renvoie la tangente de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par sa tangente.

Fonction :

tanh ( x )

La fonction tanh renvoie la tangente hyperbolique de son paramètre numérique. Si x n'est pas scalaire, chaque élément est remplacé par sa tangente hyperbolique.

Les tableaux

Fonction :

band ( m )

La fonction band calcule les largeurs de bande et les profils supérieurs et inférieurs de la matrice carrée m. La largeur de bande de ligne d'une ligne particulière est le nombre d'éléments à gauche de la diagonale de cette ligne, mais sans inclure les éléments nuls consécutifs au début de cette ligne. De même, la largeur de bande de colonne d'une colonne particulière est le nombre d'éléments au-dessus de la diagonale de cette colonne, mais sans inclure les éléments nuls consécutifs au début de cette colonne. Notez que, pour une matrice diagonale, toutes les largeurs de bande de ligne et de colonne sont nulles. La largeur de bande inférieure est la plus grande de toutes les largeurs de bande de ligne et la largeur de bande supérieure est la plus grande de toutes les largeurs de bande de colonne. Le profil inférieur est la somme de toutes les largeurs de bande de ligne et le profil supérieur est la somme de toutes les largeurs de bande de colonne.

Cette fonction renvoie un vecteur réel à quatre éléments. Dans l'ordre, ces éléments sont les suivants : largeur de bande inférieure, profil inférieur, largeur de bande supérieure et profil supérieur.

La réduction de profil peut être très efficace pour réduire le temps et la mémoire nécessaires à la factorisation d'une matrice. La fonction gpskca fournit une approche pour y parvenir.

Voir aussi gpskca.

Fonction :

bdiag ( x; m; n )

La fonction bdiag imite la fonction diag, mais dans un sens «block». La matrice x est supposée être composée de m lignes et n colonnes de blocs étant eux-mêmes des matrices. Si m ou n est 0, alors la matrice renvoyée a les blocs de x sur sa diagonale et est nulle ailleurs. Sinon, les blocs de la diagonale de x sont ajoutés ensemble.

Un exemple du premier cas est :

> M = magic (4)
                [  9   7   6  12 ]
                [  4  14  15   1 ]
                [ 16   2   3  13 ]
                [  5  11  10   8 ]
bdiag (M; 0; 2)
                [           9          7          .          . ]
                [           4         14          .          . ]
                [          16          2          .          . ]
                [           5         11          .          . ]
                [           .          .          6         12 ]
                [           .          .         15          1 ]
                [           .          .          3         13 ]
                [           .          .         10          8 ]

Un exemple du dernier cas est :

> bdiag ( M; 2; 2 )
                [  9   7   3  13 ]
                [  4  14  10   8 ]

x doit être un scalaire, un vecteur ou une matrice. Après avoir été converti en matrice, si nécessaire, le nombre de lignes de x doit être divisible par m (sauf si m est égal à 0) et le nombre de colonnes de x doit être divisible par n (sauf si n est égal à 0).

Voir aussi btrans et diag.

Fonction :

btrans ( x; m; n )

La fonction btrans imite l'opérateur de transposition, mais dans un sens «block». La matrice x est supposée être composée de m lignes et n colonnes de blocs étant eux-mêmes des matrices. Les blocs eux-mêmes ne sont pas transposés, mais sont simplement déplacés sur la diagonale.

Par exemple :

> M = magic (4)
                [  9   7   6  12 ]
                [  4  14  15   1 ]
                [ 16   2   3  13 ]
                [  5  11  10   8 ]
> btrans (M; 2; 2)
                [  9   7  16   2 ]
                [  4  14   5  11 ]
                [  6  12   3  13 ]
                [ 15   1  10   8 ]

x doit être un scalaire, un vecteur ou une matrice. Après avoir été converti en matrice, si nécessaire, le nombre de lignes de x doit être divisible par m et le nombre de colonnes de x doit être divisible par n.

Voir aussi bdiag.

Fonction :

circshift ( x; s )

La fonction circshift décale les éléments du tableau x. Le paramètre s est un vecteur : chacun de ses éléments spécifie la distance de décalage pour la dimension correspondante de x. Un décalage positif est vers le bas ou vers la droite; un décalage négatif est vers le haut ou vers la gauche. Si elle n'est pas spécifiée, la distance de décalage est nulle (ce qui signifie qu'il n'y a pas de décalage). Si x est un tableau, la fonction est appliquée à chacun de ses membres.

Par exemple :

> x = fill (3,3; 1:9)
                [ 1   2   3 ]
                [ 4   5   6 ]
                [ 7   8   9 ]
> circshift (x; 1)
                [ 7   8   9 ]
                [ 1   2   3 ]
                [ 4   5   6 ]
> circshift (x; 0,1)
                [ 3   1   2 ]
                [ 6   4   5 ]
                [ 9   7   8 ]
> circshift (x; 1,1)
                [ 9   7   8 ]
                [ 3   1   2 ]
                [ 6   4   5 ]

Fonction :

combine ( u; v )

La fonction combine ajoute les vecteurs u et v, en supprimant tous les éléments redondants, à l'exception du premier. C'est exactement comme la fonction union, sauf que le résultat n'est pas trié.

Fonction :

cram ( shape; x )

Cette fonction utilise les éléments de x pour créer une entité décrite par le vecteur shape. Si shape est NULL ou ne contient aucun élément, un scalaire est renvoyé. Si shape contient un élément, un vecteur de longueur shape[1] est renvoyé. Si shape contient deux éléments, une matrice avec des lignes shape[1] et des colonnes shape[2] est renvoyée.

Les éléments de x sont utilisés, dans l'ordre, pour remplir la nouvelle entité. Pour les matrices, cela se fait par lignes. Si l'entité renvoyée contient plus d'éléments que x, elle est complétée par des zéros ou des chaînes nulles. Par exemple, cram( 5; 1,2 ) renvoie le vecteur (1,2,0,0,0).

Si la valeur renvoyée est un tableau, elle peut être dense ou éparse. Le code essaiera de faire un choix raisonnable, mais évite de passer trop de temps à décider. Par exemple, cram( 1000; 1 ) renvoie un vecteur épars car il est immédiatement évident que la plupart de ses éléments sont nuls. D'autre part, cram( 1000; (1:1000)<2 ) est dense même s'il serait plus efficace de l'entreposer clairsemé ; puisque son deuxième argument est un vecteur dense, cram devrait vérifier la plupart de ses éléments pour s'en rendre compte.

La fonction form est identique à cette fonction, sauf que les tableaux qu'elle renvoie sont toujours denses.

Voir aussi fill, form et zero.

Fonction :

dense ( x )

La fonction dense convertit son tableau de paramètres en entreposage dense. Voir aussi sparse.

Fonction :

diag ( x )

La fonction diag effectue deux tâches différentes, selon la classe de x. Si x est une matrice, sa diagonale est renvoyée sous forme de vecteur. Si x est un vecteur, une matrice est renvoyée dont la diagonale est x et qui est nulle ailleurs. (Si x est un scalaire, elle est renvoyée intacte.)

Voir aussi bdiag.

Fonction :

dice ( s )

La fonction dice prend un caractère scalaire et renvoie un vecteur de caractères dont chaque élément est un caractère unique de s. Par exemple, l'expression dice("Go dawgs!") donne :

( "G", "o", " ", "d", "a", "w", "g", "s", "!" )

Voir aussi split.

Fonction :

diff ( v )

La fonction diff prend un vecteur numérique v et renvoie un vecteur de différences entre ses éléments. Si v a n éléments, alors le vecteur de retour est :

v[2]-v[1], v[3]-v[2], ..., v[n]-v[n-1]

Le vecteur de retour a un élément de moins que v. Si v a des étiquettes, alors le vecteur de retour contient tous les éléments sauf le dernier.

Une utilisation simple de diff est de calculer des approximations de différence directe pour la pente d'une courbe. Si c est un vecteur contenant les ordonnées de la courbe dans ses éléments et les abscisses dans ses étiquettes, alors l'expression :

  1. diff (c) / diff (unlabel (c.eid))

renvoie une approximation de sa pente. (L'appel à unlabel est probablement inutile dans la plupart des cas, mais il évite les problèmes lorsque les étiquettes de c ont elles-mêmes des étiquettes.)

Fonction :

exsparse ( x )

Cette fonction désassemble une matrice et la renvoie sous sa forme «coordonnée», adaptée au réassemblage par la fonction mksparse. Une table est renvoyée, contenant les membres shape, rows, cols et values. Le paramètre de matrice x doit être numérique. Malgré le nom de la fonction, il n'est pas nécessaire qu'elle soit éparse.

Voir aussi mksparse.

Fonction :

fill ( shape; x )

Cette fonction utilise les éléments de x pour créer une entité décrite par le vecteur shape. Si shape est NULL ou ne contient aucun élément, un scalaire est renvoyé. Si shape contient un élément, un vecteur de longueur shape[1] est renvoyé. Si shape contient deux éléments, une matrice avec des lignes shape[1] et des colonnes shape[2] est renvoyée.

Les éléments de x sont utilisés, dans l'ordre, pour remplir la nouvelle entité. Pour les matrices, cela se fait par lignes. Si l'entité renvoyée contient plus d'éléments que x, les éléments de x sont réutilisés. Par exemple, fill( 5; "a","b" ) renvoie le vecteur ("a","b","a","b","a").

Lorsque la valeur de retour de fill est un vecteur ou une matrice, elle sera toujours dense. Voir la fonction cram pour les tableaux de retour clairsemés.

La fonction form diffère de cette fonction uniquement en ce qu'elle remplit avec des zéros plutôt que de réutiliser des éléments de x.

Voir aussi form, cram et zero.

Fonction :

find ( a; b )

La fonction find localise les éléments de b ayant les valeurs données par a et renvoie un vecteur contenant leurs numéros d'éléments. Par exemple, find( 2,3; 0,1,2,3,4 ) renvoie le vecteur (3,4). Une utilisation courante est dans une expression comme A[find(77;A.rid);], renvoyant la ou les lignes de a ayant l'étiquette de ligne 77.

Si a est un scalaire, alors find(a;b) renvoie les numéros d'éléments de b, triés du plus petit au plus grand, pour lesquels l'élément correspondant de b est égal à a. Si a est un vecteur, alors find(a;b) renvoie la même chose que find(a[1];b),find(a[2];b),....

Voir aussi grep et lose.

Fonction :

first ( v )

La première fonction renvoie l'index du premier élément «vrai» du vecteur v. Si aucun élément n'est trouvé, 0 est renvoyé.

Voir aussi find et last.

Fonction :

form ( shape; x )

Cette fonction utilise les éléments de x pour créer une entité décrite par le vecteur shape. Si shape est NULL ou ne contient aucun élément, un scalaire est renvoyé. Si shape contient un élément, un vecteur de longueur shape[1] est renvoyé. Si shape contient deux éléments, une matrice avec des lignes shape[1] et des colonnes shape[2] est renvoyée.

Les éléments de x sont utilisés, dans l'ordre, pour remplir la nouvelle entité. Pour les matrices, cela se fait par lignes. Si l'entité renvoyée contient plus d'éléments que x, elle est complétée par des zéros ou des chaînes de caractères nulles. Par exemple, form( 5; "a","b" ) renvoie le vecteur ("a","b","","","").

Lorsque la valeur renvoyée par form est un vecteur ou une matrice, elle sera toujours dense. Voir la fonction cram pour les tableaux de retour clairsemés.

La fonction fill diffère de cette fonction uniquement en ce qu'elle réutilise les éléments de x plutôt que de les remplir avec des zéros.

Voir aussi fill, cram et zero.

Fonction :

full ( x )

La fonction complète convertit une matrice stockée sous la forme «sparse_upper» sous la forme «sparse».

Fonction :

gpskca ( m; flag )

La fonction gpskca tente de trouver une permutation symétrique des lignes et des colonnes de la matrice m pour réduire soit sa bande passante, soit son profil. Si le paramètre flag est "true" (au sens de la fonction test), alors l'algorithme Gibbs-Poole-Stockmeyer est utilisé pour la réduction de la bande passante ; sinon, l'algorithme Gibbs-King est utilisé pour la réduction du profil. Voir la description de la fonction band pour une définition de ces termes.

La valeur de retour est la permutation, donnée sous la forme d'un vecteur entier de longueur égale à l'ordre de m. Considérez l'exemple d'interaction suivant :

> a = symmetric (magic(6) > 25);
> band (a)
    ( 4, 13, 4, 13 )
> v = gpskca (a);
> b = a[v;v];
> band (b)
    ( 2, 9, 2, 9 )

Tout d'abord, la matrice a clairsemée et symétrique est créée. La fonction band montre qu'elle a une bande passante de 4 et un profil de 13. Ensuite, gpskca fournit une permutation pour réduire le profil. La matrice b est définie comme égale à a mais avec cette permutation appliquée. Enfin, band montre que cette permutation réduit à la fois la bande passante (à 2) et le profil (à 9).

La matrice m doit être symétrique ou hermitienne. Cette fonction utilise la sous-routine GPSKCA écrite par John Lewis.

Voir aussi band.

Fonction :

grep ( expr; v )

La fonction grep recherche les éléments du vecteur v correspondant au motif expr. Le motif est une expression régulière étendue étant donnée à la fonction egrep de UNIX pour effectuer la recherche.

Les chaînes de caractères dans v ne doivent pas contenir de saut de ligne, sinon les résultats seront généralement erronés.

Voici quelques exemples (la saisie utilisateur est précédée du prompt `>') :

> grep ("a"; "ab", "ac", "bc")
    ( 1, 2 )

> grep ("9$"; 1:40)
    ( 9, 19, 29, 39 )

> m = magic (3)
    [ 8  1  6 ]
    [ 3  5  7 ]
    [ 4  9  2 ]
> m.rid = "top", "middle", "bottom";
> m[ grep ("top|bottom"; m.rid); ]
    [ 8  1  6 ]
    [ 4  9  2 ]

Il s'agit d'une implémentation terriblement inefficace (peut-être qu'un jour Algae aura des expressions régulières intégrées), mais peut-être la trouverez-vous utile.

Voir aussi find et lose.

Fonction :

hermitian ( x )

Cette fonction renvoie la partie hermitienne de la matrice numérique carrée x. Une matrice hermitienne a une symétrie complexe-conjuguée. Sa diagonale doit nécessairement être réelle. La matrice renvoyée est complexe uniquement si x est complexe.

Si x a des étiquettes de ligne et de colonne, elles doivent correspondre.

Voir aussi symétrique.

Fonction :

ident ( n )

La fonction ident renvoie une matrice d'identité avec n lignes et colonnes.

Fonction :

imax ( v )

Si v est un vecteur, cette fonction renvoie le numéro de l'élément ayant la plus grande valeur. Si plusieurs éléments sont qualifiés, le numéro du premier est renvoyé.

Si v est une matrice, un vecteur est renvoyé, chaque élément donnant le numéro de ligne de la plus grande valeur dans la colonne correspondante. Là encore, si plusieurs éléments sont qualifiés, le premier est donné.

Si v est un tableau, la fonction imax est appliquée à chacun de ses membres.

Le paramètre v ne peut pas être un scalaire et ne doit pas avoir de type complexe. Notez que imax(v) n'est pas nécessairement égal à imin(-v).

Voir également imin, max, min, isort et sort.

Fonction :

imin ( v )

Si v est un vecteur, cette fonction renvoie le numéro de l'élément ayant la plus petite valeur. Si plusieurs éléments sont qualifiés, le numéro du dernier est renvoyé.

Si v est une matrice, un vecteur est renvoyé, chaque élément donnant le numéro de ligne de la plus petite valeur dans la colonne correspondante. Là encore, si plusieurs éléments sont qualifiés, le dernier est donné.

Si v est un tableau, la fonction imin est appliquée à chacun de ses membres.

Le paramètre v ne peut pas être un scalaire et ne doit pas avoir de type complexe. Notez que imin(v) n'est pas nécessairement égal à imax(-v).

Voir également imax, max, min, isort et sort.

Fonction :

isort ( v )

Cette fonction trie les éléments du vecteur v par ordre croissant et renvoie un vecteur contenant les indices correspondants. Par exemple, sort(20,40,10,30) renvoie le vecteur (3,1,4,2). L'expression v[isort(v)] renvoie en fait le vecteur trié v, bien que la fonction intégrée sort le fasse plus efficacement. Les nombres complexes sont triés principalement par valeur réelle et secondairement par valeur imaginaire.

Voir aussi sort, max, min et set.

Fonction :

label ( x; a; b )

La fonction label attribue des étiquettes aux vecteurs et aux matrices. Si x est un vecteur, a est attribué comme étiquettes d'éléments. Si x est une matrice, a et b sont attribués comme étiquettes de lignes et de colonnes, respectivement. Si x a une autre classe, une exception est levée.

Voir aussi unlabel.

Fonction :

last ( v )

La dernière fonction renvoie l'index du dernier élément «vrai» du vecteur v. Si aucun élément n'est trouvé, 0 est renvoyé.

Voir aussi find et first.

Fonction :

linspace ( a; b; n )

La fonction linspace génère un vecteur de n éléments, espacés uniformément entre a et b. Les trois paramètres doivent être (ou être convertibles en) des scalaires. L'argument n doit être (ou arrondi à) un entier supérieur à un.

L'opérateur de génération de vecteur `:' génère également des vecteurs uniformément espacés. Avec l'opérateur, le nombre d'éléments est déterminé à partir de l'espacement spécifié; avec la fonction linspace, l'espacement est déterminé à partir du nombre d'éléments spécifié. Notez également que le dernier élément du vecteur renvoyé par linspace est égal à b, ce qui n'est pas nécessairement le cas avec l'opérateur `:'.

Voir aussi logspace.

Fonction :

logspace ( a; b; n )

La fonction logspace génère un vecteur de n éléments, espacés logarithmiquement entre a et b. Les trois paramètres doivent être (ou pouvoir être convertis en) des scalaires. a et b doivent être non nuls et n doit être (ou arrondi à) un entier supérieur à un.

L'espacement logarithmique signifie que le logarithme du vecteur de résultat est un vecteur uniformément espacé. Cela signifie également que le rapport entre deux éléments adjacents est constant. Notez que même si a et b sont tous deux réels, le résultat sera complexe s'ils ont des signes opposés et qu'un résultat complexe ne formera pas nécessairement une ligne droite dans le plan complexe.

Voir aussi linspace.

Fonction :

lose ( a; b )

La fonction lose localise les éléments de b n'ayant pas les valeurs données par a et renvoie un vecteur contenant leurs numéros d'éléments. Par exemple, lose( 2,3; 0,1,2,3,4 ) renvoie le vecteur (1,2,5). Une utilisation courante est dans une expression telle que A[lose(77;A.rid);], qui renvoie toutes les lignes de a n'ayant pas l'étiquette de ligne 77.

Si a est un scalaire, alors lose(a;b) renvoie les numéros d'éléments de b, triés du plus petit au plus grand, pour lesquels l'élément correspondant de b n'est pas égal à a. Si a est un vecteur, alors lose(a;b) renvoie l'intersection des résultats de lose(a[1];b), lose(a[2];b),...

Voir aussi find.

Fonction :

magic ( n )

La fonction magique renvoie un carré magique d'ordre n. (Quel système serait complet sans elle ?) Les éléments d'un carré magique sont constitués de tous les entiers de 1 à n^2, disposés de manière à ce que la somme des lignes, des colonnes et des deux diagonales soit égale.

n doit être supérieur à 0. Il n'existe pas de carré magique pour l'ordre 2.

Fonction :

matrix ( x )

Cette fonction convertit son paramètre x en matrice si possible. Les scalaires deviennent des matrices un par un, les vecteurs deviennent des matrices avec une seule ligne et les matrices restent inchangées. Si x est NULL, matrix renvoie une matrice réelle avec zéro ligne et zéro colonne.

Voir aussi scalar et vector.

Fonction :

max ( v )

Si v est un vecteur, cette fonction renvoie sa plus grande valeur. Si v est une matrice, alors un vecteur est renvoyé, chaque élément donnant la plus grande valeur de tout élément de la colonne correspondante.

Si v est un tableau, alors la fonction max est appliquée à chacun de ses membres.

Le paramètre v ne peut pas être un scalaire et ne doit pas avoir de type complexe.

Voir aussi min, imax, imin, isort et sort.

Fonction :

merge ( x; y )

Cette fonction fusionne deux entités, x et y, en fonction de leurs étiquettes. Le résultat a des étiquettes étant constituées de l'union des étiquettes de x et y. Ses éléments proviennent des éléments correspondants de x et y ; ils sont additionnés lorsque le même élément apparaît dans les deux.

Ceci est démontré par la session interactive suivante :

> A = fill (3,3; 1:9)
                [  1   2   3 ]
                [  4   5   6 ]
                [  7   8   9 ]
> A.rid = A.cid = 1:3;
> B = fill (3,3; 10:90:10)
                [ 10  20  30 ]
                [ 40  50  60 ]
                [ 70  80  90 ]
> B.rid = B.cid = 2:4;
> merge (A; B)
                [  1   2   3   0 ]
                [  4  15  26  30 ]
                [  7  48  59  60 ]
                [  0  70  80  90 ]

Si x et y ne sont pas des vecteurs ou des matrices, ils sont simplement additionnés.

Fonction :

min ( v )

Si v est un vecteur, cette fonction renvoie sa plus petite valeur. Si v est une matrice, alors un vecteur est renvoyé, chaque élément donnant la plus petite valeur de tout élément de la colonne correspondante.

Si v est un tableau, alors la fonction min est appliquée à chacun de ses membres.

Le paramètre v ne peut pas être un scalaire et ne doit pas avoir de type complexe.

Voir aussi max, imax, imin, isort et sort.

Fonction :

mksparse ( t )

Cette fonction renvoie une matrice creuse dont les dimensions et les éléments sont donnés par les membres de la table t. Si le membre shape existe, il doit s'agir d'un vecteur avec deux éléments spécifiant le nombre de lignes et de colonnes de la matrice. S'il n'existe pas, la matrice est dimensionnée juste assez grande pour inclure tous les éléments donnés. Les membres rows, cols et values ??doivent tous exister ; ce sont des vecteurs, tous de même longueur, dont les éléments correspondants spécifient respectivement le numéro de ligne, le numéro de colonne et la valeur de chaque élément spécifié de la matrice. Si un élément n'est pas spécifié, il est nul. Si un élément est donné plusieurs fois, sa valeur est la somme des valeurs données.

La session interactive suivante fournit un exemple :

> mksparse ({shape=3,4; rows=1,2,3; cols=1,3,2; values=10,11,12})
    [          10          .          .          . ]
    [           .          .         11          . ]
    [           .         12          .          . ]

Le vecteur de valeurs doit être de type numérique. Si t est NULL, une matrice réelle avec 0 lignes et 0 colonnes est renvoyée.

Voir aussi sparse et exsparse.

Fonction :

norm ( x; p )

La fonction norm calcule la norme p de x, où p est 1, 2, «frobenius» ou «infinity». (Ces deux derniers peuvent être abrégés en «frob» et «inf».) Si p n'est pas spécifié, la norme 2 est utilisée.

Pour x complexe, les normes 1 et «infinity» ne traitent pas de la grandeur de chaque élément, mais de la somme des valeurs absolues des parties réelles et imaginaires.

Fonction :

pick ( x )

Cette fonction renvoie un vecteur contenant les indices des éléments non nuls du vecteur d'entrée numérique x. Par exemple, l'expression :

  1. V [ pick (V < 0) ]

renvoie tous les éléments négatifs de V.

Voir aussi find.

Fonction :

product ( x )

La fonction product calcule le produit des éléments d'un tableau. Si x est un scalaire, il est renvoyé sans changement. Si x est un vecteur, le produit de tous ses éléments est renvoyé. Si x est une matrice, un vecteur est renvoyé, dont chaque élément est le produit des éléments des colonnes correspondantes de x. Si x est un tableau, la fonction product est appliquée à chacun de ses membres.

Fonction :

rand ( shape )

Cette fonction génère des nombres pseudo-aléatoires avec une distribution uniforme dans l'intervalle de 0 à 1. Appelée sans paramètre, elle renvoie un scalaire. Sinon, la forme vectorielle spécifie un vecteur ou une matrice ; voir la fonction readnum pour plus d'informations.

Le générateur de nombres aléatoires peut être «initialisé» avec la fonction srand. Si vous n'appelez pas srand, l'initialisation est basée sur l'horloge du système. Notez que rand et randn partagent la même initialisation.

Voir aussi randn et srand.

Fonction :

randn ( shape )

Cette fonction génère des nombres pseudo-aléatoires à partir d'une distribution normale avec une moyenne nulle et une variance unitaire. Appelée sans paramètre, elle renvoie un scalaire. Sinon, la forme vectorielle spécifie un vecteur ou une matrice ; consultez la fonction readnum pour plus d'informations.

Le générateur de nombres aléatoires peut être «initialisé» avec la fonction srand. Si vous n'appelez pas srand, l'initialisation est basée sur l'horloge du système. Notez que rand et randn partagent la même initialisation.

Voir également rand et srand.

Fonction :

reverse ( v )

La fonction reverse inverse simplement l'ordre des éléments dans le vecteur v. Par exemple, reverse(1,2,3) renvoie le vecteur (3,2,1).

Fonction :

scalar ( x )

Cette fonction convertit son paramètre x en scalaire si possible. Voir aussi matrix et vector.

Fonction :

select ( x )

La fonction select sélectionne un élément au hasard dans le vecteur donné. Le résultat est un scalaire. Le vecteur x doit avoir au moins un élément.

Fonction :

seq ( n )

La fonction seq renvoie un vecteur d'entiers consécutifs compris entre 1 et n. Le paramètre n est d'abord arrondi à l'entier le plus proche ; s'il est inférieur à 1, un vecteur de longueur nulle est renvoyé.

Fonction :

shape ( x )

Cette fonction renvoie la «forme» (c'est-à-dire les dimensions) de son paramètre x. Cette valeur de retour a la même forme que celle utilisée pour les arguments de forme de fonctions telles que readnum et rand. Si x est un scalaire, NULL est renvoyé. Si x est un vecteur, un scalaire est renvoyé ayant la longueur de x comme valeur. Si x est une matrice, un vecteur est renvoyé ayant le nombre de lignes et le nombre de colonnes comme premier et deuxième éléments, respectivement. Si x a une autre classe, une exception est levée.

Fonction :

sign ( v )

La fonction sign renvoie un tableau de la même taille que v. Chaque élément du tableau renvoyé est soit -1, 0 ou +1, selon que l'élément correspondant de v est respectivement négatif, nul ou positif. Le paramètre v doit être un scalaire numérique ou un tableau.

Fonction :

sort ( v )

Cette fonction trie les éléments du vecteur v par ordre croissant. Par exemple, sort(20,40,10,30) renvoie le vecteur (10,20,30,40). Les nombres complexes sont triés principalement par valeur réelle et secondairement par valeur imaginaire.

Voir aussi isort, max, min et set.

Fonction :

sparse ( x )

Cette fonction convertit son paramètre x en entreposage clairsemé.

Fonction :

srand ( s )

La fonction srand est utilisée pour «amorcer» le générateur de nombres aléatoires rand. (OK, ce sont en fait des nombres pseudo-aléatoires.) La graine s détermine la séquence de nombres renvoyés par rand. Si s est NULL (ou si srand n'est jamais appelé du tout), alors la graine est extraite de l'horloge du système. Voir aussi rand.

Fonction :

sum ( x )

La fonction sum additionne les éléments de tableaux. Si x est un scalaire, il est renvoyé sans changement. Si x est un vecteur, la somme de tous ses éléments est renvoyée. Si x est une matrice, un vecteur est renvoyé, dont chaque élément est la somme des éléments des colonnes correspondantes de x.

Fonction :

surprise ( rows; cols; type; density; symmetry; other )

La fonction surprise renvoie une matrice plus ou moins aléatoire dont les caractéristiques sont données par les paramètres d'entrée. Elle peut être utile à des fins de test ou de chronométrage.

Chacun des paramètres de surprise peut être un vecteur, auquel cas l'un de ses membres est choisi au hasard pour cette caractéristique. Par exemple, si rows est le vecteur 4,5,6, le tableau résultant comportera 4, 5 ou 6 lignes.

Les paramètres rows et cols spécifient le nombre de lignes et de colonnes du tableau. Le choix des dimensions a une priorité inférieure à celle des autres caractéristiques, de sorte que toutes les dimensions incompatibles avec d'autres choix sont ignorées. Par exemple, considérons l'appel :

  1. surprise (3,4; 4,5; "real"; ; "general","symmetric")

Cela spécifie une matrice réelle étant soit générale, soit symétrique. Si la symétrie générale est choisie, le tableau aura soit 3 ou 4 lignes et soit 4 ou 5 colonnes. Cependant, si un tableau symétrique est choisi, il doit être carré et le résultat aura 4 lignes et 4 colonnes.

D'autre part, les dimensions spécifiées peuvent affecter le choix des autres caractéristiques. Par exemple, dans l'appel :

  1. surprise (3; 4; "real"; ; "general","symmetric")

le résultat ne sera pas symétrique, car les dimensions l'interdisent.

Le paramètre type peut contenir une ou toutes les chaînes de caractères "integer", "real" ou "complex". Seuls les types numériques sont pris en charge. La valeur par défaut est "real".

Le paramètre density spécifie le rapport approximatif entre les éléments non zéros et le nombre total d'éléments du tableau. Pour les tableaux diagonaux, seuls les éléments diagonaux sont pris en compte. La valeur par défaut est 1,0.

Le paramètre symmetry peut être "general", "symmetric" ou "hermitian". La valeur par défaut est "general".

L'autre paramètre peut être "none", "diagonal" ou "positive_definite". La valeur par défaut est "none".

Fonction :

symmetric ( x )

Cette fonction renvoie la partie symétrique de la matrice numérique carrée x. Si x possède à la fois des libellés de ligne et de colonne, ils doivent correspondre.

Voir aussi hermitian.

Fonction :

tril ( a; k )

La fonction tril renvoie la partie «triangulaire» inférieure de la matrice a. La matrice renvoyée est identique à a, sauf que, pour tout i, tous les éléments a[i;i+k+1], a[i;i+k+2],... sont nuls. Si k est NULL, sa valeur par défaut est zéro. Voici un exemple :

> tril (magic (4); 1)
                [  9   7   0   0 ]
                [  4  14  15   0 ]
                [ 16   2   3  13 ]
                [  5  11  10   8 ]

Fonction :

triu ( a; k )

La fonction triu renvoie la partie «triangulaire» supérieure de la matrice a. La matrice renvoyée est identique à a, sauf que, pour tout i, tous les éléments a[i;i+k-1], a[i;i+k-2],... sont zéros. Si k est NULL, sa valeur par défaut est zéro. Voici un exemple :

> triu (magic (4); 1)
                [  0   7   6  12 ]
                [  0   0  15   1 ]
                [  0   0   0  13 ]
                [  0   0   0   0 ]

Fonction :

unlabel ( x )

La fonction unlabel supprime les étiquettes de son paramètre. Si x est un vecteur ou une matrice, elle définit les étiquettes sur NULL et renvoie le résultat. Si x a une autre classe, elle est renvoyée sans changement.

Fonction :

vector ( x )

Cette fonction convertit son paramètre x en vecteur si possible. Les scalaires deviennent des vecteurs à un élément. Si x est une matrice avec une ligne ou une colonne, elle est convertie en vecteur.

Voir aussi scalar et matrix.

Fonction :

zero ( shape )

Cette fonction génère un scalaire, un vecteur ou une matrice entier dont tous les éléments sont nuls. La forme vectorielle spécifie les dimensions de l'entité renvoyée ; consultez la fonction readnum pour plus d'informations.

Si un vecteur ou une matrice est renvoyé, il est stocké sous forme creuse. Cela peut ou non être l'entreposage le plus efficace pour votre application ; utilisez la fonction dense pour le convertir si vous le souhaitez.

Voir également dense.

Les ensembles

Fonction :

complement ( a; b )

La fonction complément renvoie le complément relatif de a dans b, c'est-à-dire l'ensemble des éléments de b n'étant pas dans a. La valeur de retour est un ensemble, que nous définissons comme un vecteur trié et non redondant. «Trié» signifie trié par valeur croissante ; les chaînes de caractères sont triées par valeurs ASCII et les nombres complexes sont triés avec les valeurs réelles comme clef primaire et les valeurs imaginaires comme clef secondaire.

Voir aussi intersection, set et union.

Fonction :

intersection ( a; b )

La fonction intersection renvoie l'intersection de l'ensemble a dans b, c'est-à-dire l'ensemble des éléments se trouvant à la fois dans a et b. La valeur renvoyée est un ensemble, que nous définissons comme un vecteur trié et non redondant. «Trié» signifie trié par valeur croissante ; les chaînes de caractères sont triées par valeurs ASCII et les nombres complexes sont triés avec les valeurs réelles comme clef primaire et les valeurs imaginaires comme clef secondaire.

Voir aussi complement, set et union.

Fonction :

set ( x )

Cette fonction transforme x en un ensemble, si possible. Un «set» est défini comme un vecteur trié et non redondant. «Trié» signifie trié par valeur croissante ; les chaînes de caractères sont triées par valeurs ASCII et les nombres complexes sont triés avec les valeurs réelles comme clé primaire et les valeurs imaginaires comme clef secondaire. «Irredondant» signifie qu'aucun élément n'a la même valeur.

Si x a des étiquettes, alors le vecteur renvoyé a également des étiquettes correspondant aux éléments conservés. Si x n'a pas d'étiquette, les étiquettes du vecteur renvoyé donnent l'index de l'élément correspondant dans x. Si x a des éléments redondants, l'élément conservé n'est pas nécessairement le premier. Par exemple, set(1,1,1).eid peut être 1, 2 ou 3.

Voir aussi complement, intersection et union.

Fonction :

union ( a; b )

La fonction union renvoie l'union des ensembles a et b. La valeur de retour est un ensemble, que nous définissons comme un vecteur trié et non redondant. «Trié» signifie trié par valeur croissante ; les chaînes de caractères sont triées par valeurs ASCII et les nombres complexes sont triés avec les valeurs réelles comme clé primaire et les valeurs imaginaires comme clef secondaire.

Voir aussi complement, intersection et set.

Algèbre linéaire

Fonction :

backsub ( afac; b )

La fonction backsub résout l'ensemble des équations linéaires A*x=b pour x. (Malgré son nom, elle effectue à la fois la substitution avant et arrière.) Le paramètre afac doit contenir la factorisation de A renvoyée sous forme de tableau par l'une des fonctions factor ou chol. Le paramètre b fournit le côté droit.

Cette fonction gère à la fois les facteurs LAPACK (denses) et SuperLU (épaissis). Elle détermine la méthode de résolution appropriée en fonction des membres de la table afac.

Si BCSLIB-EXT (une bibliothèque mathématique éparse produite par Boeing Computer Services) est disponible sur votre système et qu'Algae a été compilé pour elle, alors la fonction backsub peut l'utiliser. Si afac contient des facteurs calculés par des routines BCSLIB-EXT (dans factor ou chol), alors backsub appellera les routines correspondantes pour effectuer la substitution arrière.

Voir aussi chol, factor et solve.

Fonction :

chol ( m )

La fonction chol calcule la factorisation de Cholesky de la matrice symétrique définie positive m. Les facteurs sont renvoyés dans une table, pouvant contenir une variété de membres selon le type et la densité de m. Par exemple, si m est une matrice réelle et dense, alors «L» (la sortie de la routine DSYTRF de LAPACK) et «RCOND» sont renvoyés. Pour l'instant, vous devrez fouiller dans le code si vous voulez vraiment comprendre la sortie. L'idée, cependant, est que des fonctions comme backsub peuvent leur donner un sens pour que vous n'ayez pas à le faire.

Bien que ses autres membres varient, la table renvoyée par chol contient toujours un membre nommé «RCOND». Ce scalaire réel non négatif est une estimation de l'inverse du nombre de conditions de m. Si «RCOND» est très petit (c'est-à-dire que le nombre de conditions est très grand), alors la matrice m est mal conditionnée. Un message d'avertissement est produit si «RCOND» est inférieur à 1,0E-8.

La principale différence entre les fonctions chol et factor est que chol exige que la matrice soit symétrique et définie positive. Dans ce cas, aucun pivotement n'est requis ; cela se traduit généralement par une économie de temps d'exécution par rapport à la fonction factor.

À moins que la matrice m ne soit diagonale (ou que BCSLIB-EXT ne soit utilisé), chol utilise une méthode dense de LAPACK. Par conséquent, factor est préféré à chol pour les systèmes volumineux et clairsemés.

Si BCSLIB-EXT (une bibliothèque mathématique clairsemée produite par Boeing Computer Services) est disponible sur votre système et qu'Algae a été compilé pour elle, alors chol peut utiliser ses routines pour factoriser des matrices clairsemées. À leur tour, les fonctions backsub et solve peuvent utiliser ces facteurs pour résoudre des équations linéaires. Il est souvent utile de calculer les facteurs d'une matrice, puis de les enregistrer (en utilisant put) pour une utilisation ultérieure. Gardez toutefois à l'esprit que si ces facteurs ont été calculés avec les routines BCSLIB-EXT, la version d'Algae avec laquelle vous avez l'intention de les utiliser doit également prendre en charge BCSLIB-EXT. La table renvoyée par chol contient le membre HOLD si et seulement si une routine BCSLIB-EXT a été utilisée pour la produire. Le BCSLIB-EXT n'est jamais utilisé sur des matrices denses.

Voir aussi backsub, factor et solve.

Fonction :

eig ( a; b; opts )

La fonction eig calcule les valeurs propres et les vecteurs propres pour les problèmes de valeurs propres standard et généralisés :

  1. A * x = lambda * x

et :

  1. A * x = lambda * B * x

Si a est le seul paramètre de la matrice, alors lambda et x sont tous deux calculés pour le problème standard. Si une matrice b est donnée comme deuxième paramètre, alors le problème généralisé est résolu.

Un tableau d'options opts peut être donné comme dernier paramètre. S'il contient le membre no_right, alors les vecteurs propres droits x ne sont pas calculés. S'il contient le membre left, alors les vecteurs propres gauches correspondants sont calculés.

Cette fonction renvoie un tableau contenant les valeurs propres dans un membre appelé valeurs et, le cas échéant, les vecteurs propres (droits) dans un membre appelé vecteurs. Si l'option left a été donnée et que le problème est asymétrique, alors les vecteurs propres gauches sont renvoyés dans un membre appelé left_vectors.

La méthode de résolution utilisée dépend du type et de la symétrie des tableaux de coefficients. Certaines de ces méthodes impliquent des exigences strictes, telles que la définition positive, sur les matrices. Chaque cas est décrit ci-dessous, ainsi que la routine LAPACK appelée pour le résoudre.

Pour les problèmes réels, symétriques et standard, DSYEV est utilisé. Les valeurs propres sont réelles et dans l'ordre croissant; les vecteurs propres sont orthonormés.

Pour les problèmes complexes, hermitiens et standard, ZHEEV est utilisé. Les valeurs propres sont réelles et dans l'ordre croissant ; les vecteurs propres sont orthonormés.

Pour les problèmes non symétriques et standard, DGEEV est utilisé pour le type réel et ZGEEV pour le type complexe. Les valeurs propres sont complexes et les paires conjuguées complexes apparaissent consécutivement, la valeur propre ayant la partie imaginaire positive en premier. Les vecteurs propres sont normalisés pour avoir une norme euclidienne égale à 1 et la plus grande composante réelle.

Pour les problèmes réels, symétriques et généralisés, DSYGV est utilisé. Cette méthode nécessite que a soit symétrique et que b soit symétrique et défini positif. Les valeurs propres sont réelles et dans l'ordre croissant. Les vecteurs propres sont b-orthonormaux.

Pour les problèmes réels, non symétriques et généralisés, on utilise DGGEV. Cette méthode effectue un équilibrage complet sur a et b. Les valeurs propres sont complexes et les paires conjuguées complexes apparaissent consécutivement, la valeur propre ayant la partie imaginaire positive en premier. Notez cependant que les valeurs propres sont renvoyées dans un tableau ; le membre num contient leurs numérateurs et le membre denom contient leurs dénominateurs. Les quotients peuvent facilement déborder ou déborder, et le dénominateur (et peut-être aussi le numérateur) peut être nul. Chaque vecteur propre est mis à l'échelle de sorte que la somme des valeurs absolues des parties réelle et imaginaire de la plus grande composante soit 1, sauf que pour les valeurs propres avec un numérateur et un dénominateur tous deux nuls, le vecteur propre correspondant est nul.

Pour les problèmes complexes, hermitiens et généralisés, on utilise ZHEGV. Cette méthode nécessite que a soit hermitien et que b soit hermitien et défini positif. Les valeurs propres sont réelles et en ordre croissant. Les vecteurs propres sont b-orthonormaux.

Pour les problèmes complexes, non symétriques et généralisés, on utilise ZGGEV. Les valeurs propres et les vecteurs propres sont complexes. Notez cependant que les valeurs propres sont renvoyées dans un tableau ; le membre num contient leurs numérateurs et le membre denom contient leurs dénominateurs. Les quotients peuvent facilement déborder ou ne pas déborder, et le dénominateur (et peut-être aussi le numérateur) peut être nul. Chaque vecteur propre est mis à l'échelle de telle sorte que la somme des valeurs absolues des parties réelles et imaginaires de la plus grande composante soit égale à 1, sauf que pour les valeurs propres dont le numérateur et le dénominateur sont tous deux nuls, le vecteur propre correspondant est nul.

Voir aussi iram.

Fonction :

equilibrate ( A )

La fonction equilibrate calcule les mises à l'échelle des lignes et des colonnes destinées à équilibrer une matrice et à réduire son nombre de conditions. La matrice d'entrée A n'a pas besoin d'être carrée, mais elle doit être numérique et les deux dimensions doivent être non nulles. Si A est hermitienne ou symétrique réelle, elle doit être définie positive.

Si equilibrate réussit, elle renvoie une table contenant les membres suivants :

Membre Description
r Un vecteur contenant les facteurs d'échelle de ligne.
c Un vecteur contenant les facteurs d'échelle des colonnes.
rowcnd Le rapport (scalaire) du plus petit au plus grand des facteurs d'échelle de ligne.
colcnd Le rapport (scalaire) du plus petit au plus grand des facteurs d'échelle de la colonne.
amax La valeur absolue (scalaire) du plus grand élément de la matrice.

Même si la matrice A est symétrique ou hermitienne, les facteurs d'échelle de ligne et de colonne peuvent être identiques ou non. Dans le cas contraire, la matrice équilibrée résultante ne serait plus symétrique ou hermitienne. Vous devrez décider si l'amélioration de l'état de la matrice vaut la perte de symétrie. Les facteurs d'échelle de ligne et de colonne seront identiques pour les matrices denses, réelles et symétriques et pour les matrices denses, complexes et hermitiennes (les deux devant également être définies positives); sinon, il n'y a aucune garantie.

Souvent, appliquer les facteurs d'échelle d'équilibrage ne vaut pas la peine. En gros, si amax n'est pas proche de débordement ou de débordement inférieur et que rowcnd et colcnd sont tous deux supérieurs à 0,1, cela ne vaut probablement pas la peine de le faire.

Si equilibrate échoue, il renvoie un entier scalaire au lieu d'un tableau. Si cette valeur est positive, elle indique la ligne à l'origine du problème. Si elle est négative, sa valeur absolue indique la colonne à l'origine du problème.

Pour appliquer l'équilibrage, la matrice doit être pré- et post-multipliée par les facteurs d'échelle. Si r et c sont identiques, vous souhaiterez probablement utiliser la fonction de transformation pour préserver la symétrie. Voici un exemple d'utilisation :

  1. e = equilibrate (A);
  2. if (equal (e.r; e.c))
  3. {
  4.   Ae = transform (A; diag (e.r));
  5. else
  6.   Ae = diag (e.r) * A * diag (e.c);
  7. }

Notez cependant que cet exemple ne vérifie pas le résultat de l'équilibrage pour déterminer s'il a réussi, il applique les facteurs d'échelle sans vérifier si cela en vaut la peine, et il suppose que A obéit à l'exigence concernant la définition positive.

Fonction :

factor ( m )

La fonction factor calcule une factorisation triangulaire de la matrice m. Les facteurs sont renvoyés dans une table, pouvant contenir une variété de membres selon le type, la densité et la définition de m. Par exemple, si m est une matrice réelle, dense et symétrique, alors «LD» et «IPIV» (la sortie de la routine DSYTRF de LAPACK) sont renvoyés. Pour l'instant, vous devrez fouiller dans le code si vous voulez vraiment comprendre la sortie. L'idée, cependant, est que des fonctions comme backsub peuvent leur donner un sens pour que vous n'ayez pas à le faire.

Pour les systèmes clairsemés, le paquet SuperLU est utilisé. Ces routines réorganisent les colonnes de la matrice pour augmenter sa parcimonie et effectuent un pivotement dynamique des lignes pour la stabilité numérique. (Aucun avantage n'est tiré de la symétrie.) Pour l'ordre des colonnes, l'algorithme Multiple Minimum Degree (MMD) est utilisé si la matrice est symétrique ; sinon, l'algorithme Column Approximate Minimum Degree (COLAMD) est utilisé. Actuellement, il n'existe aucune disposition permettant de fournir votre propre ordre.

Bien que ses autres membres varient, la table renvoyée par factor contient toujours un membre nommé «RCOND». Ce scalaire réel non négatif est une estimation de la réciproque du nombre de conditions de m. Si «RCOND» est très petit (c'est-à-dire que le nombre de conditions est très grand), alors la matrice m est mal conditionnée. Un message d'avertissement est produit si «RCOND» est inférieur à 1,0E-8.

Si BCSLIB-EXT (une bibliothèque mathématique creuse produite par Boeing Computer Services) est disponible sur votre système et qu'Algae a été compilé pour elle, factor peut utiliser ses routines pour factoriser des matrices creuses. À leur tour, les fonctions backsub et solve peuvent utiliser ces facteurs pour résoudre des équations linéaires. Il est souvent utile de calculer les facteurs d'une matrice, puis de les enregistrer (en utilisant put) pour une utilisation ultérieure. Gardez toutefois à l'esprit que si ces facteurs ont été calculés avec les routines BCSLIB-EXT, la version d'Algae avec laquelle vous avez l'intention de les utiliser doit également prendre en charge BCSLIB-EXT. La table renvoyée par factor contient le membre HOLD si et seulement si une routine BCSLIB-EXT a été utilisée pour la produire. BCSLIB-EXT n'est jamais utilisé sur des matrices denses.

La principale différence entre les fonctions chol et factor est que chol exige que la matrice soit symétrique et définie positive. Dans ce cas, aucun pivotement n'est requis ; cela se traduit généralement par une économie de temps d'exécution par rapport à la fonction factor.

Voir également backsub, chol et solve.

Fonction :

fft ( x; opts )

La fonction fft calcule la transformée de Fourier discrète complexe du vecteur (ou de la matrice - voir ci-dessous) x en utilisant la méthode de la transformée de Fourier rapide. Le résultat est ordonné de telle sorte que les fréquences correspondantes augmentent (de négatives à positives). Notez qu'il s'agit d'un ordre différent de celui renvoyé par de nombreuses routines FFT.

Si x a N éléments, la transformée est un vecteur complexe de même longueur. Si N est pair, alors l'élément k de la transformée est égal à :

  1. sum (x @ exp (-2*i*pi*(k-N/2)*((1:N)-1)/N))

Si N est impair, alors l'élément k est égal à :

  1. sum (x @ exp (-2*i*pi*(k-(N+1)/2)*((1:N)-1)/N))

La méthode est plus efficace lorsque le nombre d'éléments de x est le produit de petits nombres premiers. Par exemple, un vecteur de 1021 éléments (un grand nombre premier) prend environ 100 fois plus de temps à transformer qu'un vecteur de 1024 éléments (une puissance de 2). En revanche, 1152 éléments (avec des facteurs premiers de 2 et 3) sont presque aussi rapides que 1024.

Si x a des étiquettes entières ou réelles, elles sont considérées comme les abscisses correspondantes (c'est-à-dire le temps ou la distance) et sont transformées en conséquence pour former des étiquettes pour le vecteur de résultats. Dans ce cas, les valeurs des étiquettes doivent être uniformément espacées.

Si x est une matrice, la transformation est calculée pour chaque ligne ou colonne. Par défaut, cela se fait par colonne, mais vous pouvez le modifier pour qu'il fonctionne par lignes en fournissant l'option row, comme décrit ci-dessous.

Le paramètre opts est une table d'options ; il peut contenir tout ou partie des membres suivants. (Les valeurs de ces membres n'ont aucune importance ; seule leur existence est significative.)

Membre Description
row Si x est une matrice, cette option provoque le calcul de la transformation de chaque ligne. Par défaut, les colonnes sont transformées.
estimate Lors de la planification de la transformation, utilisez une heuristique simple pour choisir rapidement un plan (probablement sous-optimal). Il s'agit de la rigueur par défaut. Cette option et les suivantes n'ont d'effet que si Algae a été lié au paquet FFTW.
measure Trouvez un plan optimisé en calculant réellement plusieurs FFT et en mesurant leur temps d'exécution.
patient Même mesure, mais prenant en compte une gamme plus large d'algorithmes. Cela peut produire un plan «plus optimal», mais au prix d'un temps de planification plus long.
exhaustive Comme patient, mais avec une gamme d'algorithmes encore plus large et un temps de planification considérablement accru.
forget Les plans sont conservés pour être utilisés sur des FFT ultérieures de même taille et de mêmes caractéristiques. L'option forget entraîne la suppression de ces informations accumulées.

Voir aussi ifft.

Fonction :

filter ( b; a; x; z )

La fonction de filtrage calcule un filtre numérique à partir de l'équation de différence standard :

  1. y[n] = b[1]*x[n] + b[2]*x[n-1] + b[3]*x[n-2] + ...
  2.                  - a[2]*y[n-1] - a[3]*y[n-2] - ...

Ce filtre est implémenté en utilisant la méthode de la «forme directe II transposée».

Fonction :

ifft ( x )

La fonction ifft calcule la transformée de Fourier discrète inverse complexe du vecteur (ou de la matrice - voir ci-dessous) x en utilisant la méthode de la transformée de Fourier rapide. L'entrée est ordonnée de telle sorte que les fréquences correspondantes augmentent (de négative à positive). Notez qu'il s'agit d'un ordre différent de celui requis par de nombreuses routines FFT inverses.

Si x a N éléments, la transformée est un vecteur complexe de même longueur. Si N est pair, alors l'élément n de la transformée est égal à :

  1. (1/N) * sum (x @ exp (2*i*pi*((1:N)-N/2)*(n-1)/N))

Si N est impair, alors l'élément n est égal à :

  1. (1/N) * sum (x @ exp (2*i*pi*((1:N)-(N+1)/2)*(n-1)/N))

La méthode est plus efficace lorsque le nombre d'éléments de x est le produit de petits nombres premiers. Par exemple, un vecteur de 1021 éléments (un nombre premier) prend environ 100 fois plus de temps à transformer qu'un vecteur de 1024 éléments (une puissance de 2). En revanche, 1152 éléments (avec des facteurs premiers de 2 et 3) sont presque aussi rapides que 1024.

Si x a des étiquettes entières ou réelles, elles sont considérées comme les abscisses correspondantes (c'est-à-dire les fréquences) et sont transformées en conséquence pour former des étiquettes pour le vecteur de résultats. Dans ce cas, les valeurs des étiquettes doivent être uniformément espacées.

Si x est une matrice, la transformation est calculée pour chaque ligne ou colonne. Par défaut, cela se fait par colonne, mais vous pouvez le modifier pour qu'il fonctionne par lignes en fournissant l'option row.

Pour une description des options valides et de leurs effets, voir la fonction fft.

Voir aussi fft.

Fonction :

inv ( a; opts )

La fonction inv calcule l'inverse d'une matrice. Cela est parfois utile, mais vous devez savoir qu'une approche alternative utilisant factor (ou chol) et solve est généralement plus efficace et précise.

La fonction inv est implémentée simplement en appelant la fonction solve avec une matrice d'identité comme deuxième paramètre. Le paramètre opts est facultatif et est passé comme troisième argument à solve. Par exemple :

  1. inv (A; {pos});

calcule l'inverse de la matrice définie positive A.

L'inverse de la matrice est souvent utilisé pour résoudre des systèmes d'équations linéaires. Si Ax=b est un tel système, où A est une matrice carrée de rang complet, alors sa solution peut être calculée comme suit :

  1. x = inv (A) * b;

Une approche plus efficace et plus précise consiste cependant à utiliser la fonction de résolution comme :

  1. x = solve (A; b);

L'utilisation de solve est appropriée même lorsque plusieurs membres droits doivent être considérés séparément. Par exemple, le code :

  1. x = {};
  2. A_inv = inv (A);
  3. for (b in members (blist))
  4. {
  5.   x.(b) = A_inv * blist.(b);
  6. }

serait mieux écrit comme :

  1. x = {};
  2. A_fac = factor (A);
  3. for (b in members (blist))
  4. {
  5.   x.(b) = solve (A_fac; blist.(b));
  6. }

Voir également backsub, chol, factor et solve.

Fonction :

iram ( n; op_func; b_func; params; options )

Cette fonction est une interface avec les routines ARPACK pour résoudre les problèmes algébriques de valeurs propres. Elle est basée sur la méthode Arnoldi implicitement redémarrée. Pour les problèmes hermitiens, il s'agit d'une méthode de Lanczos. Ce code est particulièrement bien adapté aux problèmes volumineux et clairsemés.

La fonction iram fournit presque toutes les capacités d'ARPACK. Cependant, il s'agit d'une fonction de niveau relativement bas et nécessite une utilisation très prudente. En raison de sa conception, de nombreuses erreurs de saisie simples ne peuvent pas être détectées par la fonction et peuvent bien entraîner des résultats incorrects. J'espère voir bientôt une fonction de haut niveau écrite, peut-être appelée arnoldi, appelant iram mais échange une partie de sa flexibilité contre une interface simplifiée et moins sujette aux erreurs.

Pour utiliser iram efficacement, vous aurez besoin de plus d'informations sur les différents modes de résolution que celles pouvant être incluses ici.

Le problème le plus général résolu par iram est de calculer quelques valeurs propres (lambda) et vecteurs propres (x) pour :

  1. A * x = M * x * lambda

A et B sont des matrices carrées réelles ou complexes et M est hermitienne (symétrique lorsque réelle). Il s'agit d'un problème de valeur propre standard si M est la matrice identité ; sinon, il s'agit d'un problème généralisé.

Le paramètre n spécifie la dimension du problème. Il doit s'agir d'un scalaire entier, ou au moins pouvant être converti en un.

Plutôt que de fournir directement A et B, iram nécessite des fonctions d'entrée effectuant certaines opérations sur ces matrices. Cela permet de nombreuses approches de résolution (appelées «modes»), étant décrites en détail ci-dessous. Les deux fonctions fournies par l'utilisateur sont appelées :

  1. op_func (v; params)
  2. b_func (v; params)

Les opérations requises de la fonction op_func diffèrent selon le mode de solution. Dans le cas le plus simple (mode 1), il s'agit simplement de la multiplication matrice-vecteur A*v. Le paramètre params est transmis sans changement depuis le paramètre params à iram --- il s'agit généralement d'un tableau contenant les tableaux de coefficients A et B.

Les exigences de la fonction b_func dépendent également du mode de solution. Il n'est pas du tout utilisé pour certains modes, auquel cas il peut être NULL. Comme pour op_func, le paramètre params est transmis sans changement depuis l'entrée iram.

Le paramètre options est un tableau ; ses membres spécifient diverses options de problème et de solution :

Membre Description
mode Le mode de solution entière, dont la valeur par défaut est 1.
Valeur Description
1 Il s'agit du mode «normal», réservé aux problèmes standards. La fonction op_func doit renvoyer A*v et b_func doit être NULL. Ce mode est surtout adapté à la recherche de quelques-unes des valeurs propres de plus grande magnitude. Il peut être utilisé avec n'importe quel type de problème.
2 Il s'agit du mode «inverse régulier» pour les problèmes généralisés. La fonction op_func doit renvoyer inv(B)*A*v (conceptuellement, mais vous devez utiliser factor et solve plutôt que inv), et b_func doit renvoyer B*v. Ce mode ne peut pas être utilisé avec des problèmes réels et symétriques.
3 Il s'agit du mode «shift-invert» pour les problèmes standards ou généralisés. La fonction op_func doit renvoyer inv(A-sigma*B)*B*v (conceptuellement, mais vous devez utiliser factor et solve plutôt que inv), et b_func doit renvoyer B*v. Ce mode peut être utilisé avec n'importe quel type de problème. La convergence est améliorée pour les valeurs propres étant proches de la valeur de sigma. Pour ce mode, l'option which fait référence au problème inversé, utilisez donc «LM» pour faire référence aux valeurs propres les plus proches de sigma.
4 Il s'agit du mode «flambage» pour les problèmes généralisés. La fonction op_func doit renvoyer inv(A-sigma*B)*A*v (conceptuellement, mais vous devez utiliser factor et solve plutôt que inv), et b_func doit renvoyer A*v. Ce mode ne peut être utilisé que pour les problèmes réels et symétriques. La convergence est améliorée pour les valeurs propres étant proches de la valeur de sigma. Pour ce mode, l'option which fait référence au problème inversé, utilisez donc «LM» pour faire référence aux valeurs propres les plus proches de sigma.
5 Il s'agit du mode « Cayley » pour les problèmes généralisés. La fonction op_func doit renvoyer inv(A-sigma*B)*(A+sigma*B)*v (conceptuellement, mais vous devriez utiliser factor et solve plutôt que inv), et b_func doit renvoyer B*v. Ce mode ne peut être utilisé que pour des problèmes réels et symétriques. La convergence est améliorée pour les valeurs propres qui sont proches de la valeur de sigma. Pour ce mode, l'option which fait référence au problème inversé, utilisez donc « LM » pour faire référence aux valeurs propres les plus proches de sigma.
bmat Un caractère scalaire : « I » pour les problèmes standards ou « G » pour les problèmes généralisés. La valeur par défaut est « I ».
which Un scalaire de caractère spécifiant laquelle des valeurs propres calculer. Pour un mode autre que «normal» (mode 1), cela se rapporte au problème transformé. Par exemple, avec le mode «shift-invert» (mode 3), on souhaite généralement que les vecteurs propres soient les plus proches du point de décalage. Dans le problème transformé, ce sont les valeurs propres avec la plus grande magnitude («LM»). Pour les problèmes réels et symétriques, qui doivent être l'une des suivantes : «LA» (amplitude la plus grande), «SA» (amplitude la plus petite), «LM» (amplitude la plus grande), «SM» (amplitude la plus petite) ou «BE» (les deux extrémités du spectre). Pour les problèmes non symétriques ou complexes, devant être l'une des suivantes : «LM» (amplitude la plus grande), «SM» (amplitude la plus petite), ou «LR» (réel le plus grand), «SA» (réel le plus petit), «LI» (imaginaire le plus grand), ou «SI» (imaginaire le plus petit). La valeur par défaut est «LA» pour les problèmes symétriques et «LR» pour les autres.
nev Nombre de valeurs propres à calculer. Il doit être supérieur à zéro et inférieur à n. La valeur par défaut est la plus petite de 10 et n/2. Pour les problèmes non symétriques et complexes, nev doit être inférieur à n-1.
ncv Contrôle le nombre de vecteurs d'Arnoldi générés à chaque itération. Pour les problèmes réels et symétriques, cette valeur doit être inférieure ou égale à n, doit dépasser nev et sa valeur par défaut est la plus petite valeur entre 2*nev et n. Pour les problèmes réels et non symétriques, ncv doit être inférieur ou égal à n, doit dépasser nev+1 et sa valeur par défaut est la plus petite valeur entre 2*nev+1 et n. Pour les problèmes complexes, ncv doit être inférieur ou égal à n, doit dépasser nev et sa valeur par défaut est la plus petite valeur entre 2*nev et n.
mxiter Nombre maximal d'itérations de mise à jour d'Arnoldi autorisées. La valeur par défaut est 100.
basis Si «vrai» (au sens de la fonction de test), alors iram renvoie, avec ses autres résultats, une base orthonormale pour le sous-espace invariant approximatif associé.
vectors Si «vrai» (au sens de la fonction de test), alors iram renvoie les vecteurs propres ainsi que ses autres résultats.
tol Critère d'arrêt. Si tol est NULL ou inférieur ou égal à zéro, alors la précision de la machine est utilisée.
resid S'il est présent, il s'agit d'un vecteur de longueur n qui fournit le vecteur résiduel initial. Sinon, un vecteur initial aléatoire est utilisé.
shift Un scalaire réel fournissant le point de décalage (sigma) pour une transformation spectrale. Il est utilisé dans les modes 3, 4 et 5. La valeur par défaut est 0,0.

Fonction :

leastsq ( A; b )

Cette fonction résout les systèmes linéaires surdéterminés et sous-déterminés de rang complet en utilisant une factorisation QR ou LQ. Les entrées sont le tableau de coefficients A et le RHS b. La valeur de retour est le tableau de solutions x.

Un système sous-déterminé est un système pour lequel A a moins de lignes que de colonnes. Le rang de A doit être égal au nombre de lignes de A. La valeur de retour est la solution de norme minimale.

Un système surdéterminé est un système pour lequel A a plus de lignes que de colonnes. Cette fonction traite un carré A comme s'il s'agissait d'un système surdéterminé. Le rang de A doit être égal au nombre de colonnes de A. La valeur de retour est la solution au problème des moindres carrés :

  1. minimize || B - A*X ||

Voir aussi résoudre.

Fonction :

mult ( ... )

Cette fonction multiplie une série de matrices, en effectuant les multiplications dans un ordre de façon à minimiser le nombre total d'opérations.

Seuls les paramètres non NULL les plus à gauche sont utilisés, et au plus 10 paramètres sont autorisés. Ils seront convertis en matrices si nécessaire (et possible), mais de manière indépendante du contexte. Un scalaire devient une matrice 1x1 et un vecteur devient une matrice à 1 ligne. Ceci est en contraste avec l'opérateur de multiplication d'Algae, effectuant des conversions différentes selon le contexte.

À titre d'exemple, considérons une matrice NxN A et un vecteur N b. Si vous donnez à Algae le produit A'*A*b, elle multiplie d'abord A'*A ce qui implique un ordre de N^3 opérations. Mais si vous le faites comme A'*(A*b), il n'y a qu'un ordre de N^2 opérations. La différence peut être énorme ! Avec cette fonction, vous le feriez comme mult(A';A;b'). (Notez que nous devons convertir explicitement b en une matrice avec la bonne forme.)

Fonction :

solve ( A; b; opts )

Cette fonction résout les équations linéaires A*x=b pour x. Conceptuellement, elle renvoie inv(A)*b, sauf que solve est généralement beaucoup plus efficace et précis. Si A a déjà été factorisé par les fonctions factor ou chol, alors ses facteurs (sous la forme d'un tableau renvoyé par ces fonctions) peuvent être donnés à la place de A. Si le paramètre optionnel opts contient le membre "pos", alors la méthode de Cholesky est utilisée pour factoriser A.

Voir aussi backsub, chol et factor.

Fonction :

ssi ( A; B; V; eps )

La fonction ssi utilise l'itération de sous-espace pour calculer les premières valeurs propres et les premiers vecteurs d'un problème de valeurs propres généralisé, symétrique et réel A*v=B*v*w. Les termes w et v sont respectivement les valeurs propres et les vecteurs propres.

L'itération de sous-espace est une approche efficace pour les problèmes de grande taille et peu denses et pour les problèmes pour lesquels de bonnes estimations des vecteurs propres sont disponibles. Sinon, c'est nul.

A et B doivent être des matrices réelles, symétriques et non singulières. La matrice V contient un ensemble de vecteurs de départ, un par colonne. Une tolérance de convergence peut être spécifiée avec eps ; 1.0E-6 est utilisé si eps est NULL. Un tableau est renvoyé, contenant les membres «values» et «vectors».

Voir aussi eig.

Fonction :

svd ( A; opts )

Cette fonction calcule la décomposition en valeurs singulières (SVD) de la matrice A. Dans le cas complet, la SVD s'écrit A=U*S*V', où S est une matrice réelle de mêmes dimensions que A et U et V sont les vecteurs singuliers orthogonaux (unitaires) gauche et droit. La matrice S contient les valeurs singulières sur sa diagonale et est nulle ailleurs.

Lorsque A n'est pas carré, une ou plusieurs lignes ou colonnes de S sont connues a priori comme étant nulles. Par défaut, svd renvoie alors une forme "compacte" des vecteurs singuliers, dans laquelle les colonnes correspondantes de U ou V ne sont pas incluses. Ce comportement peut être modifié en utilisant l'option full, comme décrit ci-dessous.

Le paramètre opts est une table d'options; elle peut contenir les membres novectors et full. (Les valeurs de ces membres ne sont pas pertinentes ; seule leur existence est significative.) Si opts contient le membre novectors, alors seules les valeurs singulières sont calculées. Si opts ne contient que le membre full, alors les vecteurs singuliers complets sont calculés.

Les résultats de svd sont renvoyés dans un tableau. Le membre sigma contient le vecteur des valeurs singulières, triées par ordre décroissant. Sauf si l'option novectors est spécifiée, les membres U et V contiennent les vecteurs singuliers gauche et droit correspondants.

Cette fonction appelle les routines LAPACK DGESVD et ZGESVD.

Fonction :

transform ( A; P )

La fonction de transformation effectue la transformation de coordonnées linéaires P'*A*P, où A est une matrice carrée. En fait, il n'y a que deux différences entre l'expression d'opérateur P'*A*P et l'expression de fonction transform(A;P) :

Analyse numérique

Fonction :

brent ( f; a; b; tol; param )

Cette fonction utilise la méthode de Brent pour trouver une racine unique de la fonction f, c'est-à-dire une solution à f(x)=0. Les ordonnées A et B doivent encadrer une racine, ce qui signifie que f(A)*f(B) doit être négatif. Si param est donné, il est passé comme deuxième argument à la fonction f.

Fonction :

monte ( f; limits; tol )

Cette fonction utilise la méthode de Monte Carlo pour intégrer une fonction. Les valeurs de la fonction sont obtenues en appelant la fonction f avec un paramètre vectoriel. La matrice limit décrit la région rectangulaire sur laquelle la fonction est intégrée. Elle comporte deux colonnes et autant de lignes que f a de dimensions. Chaque ligne spécifie les extrêmes de la région pour la dimension correspondante.

Le paramètre tol spécifie une tolérance d'erreur. (Ce paramètre est obligatoire : il n'y a pas de valeur par défaut.) Il n'y a pas de limite au nombre de points choisis ; monte continue de choisir des points jusqu'à ce que son estimation d'erreur d'écart type soit inférieure à tol. En général, la précision augmente uniquement comme la racine carrée du nombre de points évalués.

La méthode de Monte Carlo fournit une approche simple et facile pour résoudre (numériquement) même des intégrales multidimensionnelles complexes. Cependant, elle est notoirement inefficace. Chaque chiffre supplémentaire de précision nécessite 100 fois plus d'efforts.

Voici un exemple simple, dans lequel nous calculons l'aire d'un cercle avec un rayon unitaire. Avec le domaine, nous spécifions un carré centré sur l'origine dans lequel intégrer. Le nombre de variables indépendantes dans le problème (2 dans ce cas) est déterminé par le nombre de lignes du domaine. La fonction f prend comme paramètre un vecteur des variables indépendantes et renvoie la valeur de la fonction à ce point. Elle sera appelée de manière répétée, les variables indépendantes étant réparties de manière aléatoire dans le domaine. Pour ce problème, f renvoie 1 si le point est à l'intérieur du cercle, et 0 sinon :

domain = [-1,1; -1,1];
f = function (x) { return norm(x) < 1; };
monte (f; domain; 0.1)?
                3.040
monte (f; domain; 0.01)?
                3.120
monte (f; domain; 0.001)?
                3.142

Comme vous pouvez le constater à partir des résultats, le troisième appel à monte a donné un résultat plus précis, mais il a nécessité 10 000 fois plus d'efforts que le premier appel.

Au fait, ce problème pourrait être résolu plus rapidement avec une intégration unidimensionnelle. Mais nous connaissons déjà la réponse, n'est-ce pas ?

Fonction :

ode4 ( f; t0; tf; x0; y; tol; h; s )

La fonction ode4 utilise les formules de Runge-Kutta du quatrième et du cinquième ordre pour résoudre un problème de valeur initiale impliquant un système d'équations différentielles ordinaires. La fonction f, appelée f( t; x ), est censée renvoyer la première dérivée du vecteur d'état x par rapport à la variable indépendante t. Les paramètres t0 et tf sont les valeurs initiale et finale de la variable indépendante, et x0 est le vecteur d'état initial. Le paramètre y peut être une fonction, appelée y( t; x ), renvoyant un vecteur de valeurs de sortie. Si y est NULL, le vecteur de sortie est le vecteur d'état lui-même.

Le paramètre optionnel tol spécifie la précision souhaitée ; nous utilisons 0,001 si tol est NULL. Un pas initial peut être suggéré avec h. Le paramètre s peut être utilisé pour fournir un meilleur contrôle de la précision - si s n'est pas NULL, alors un pas est accepté si l'erreur estimée dans chaque état, divisée par le terme correspondant de s, n'est pas supérieure à tol.

La valeur de retour est une matrice contenant l'historique de sortie. Chaque colonne contient la sortie de y pour la valeur particulière de la variable indépendante donnée par l'étiquette de la colonne.

Fonction :

roots ( c )

Cette fonction calcule les racines du polynôme ayant les coefficients donnés par le vecteur c. Si c a n+1 éléments, l'équation résolue (pour x) est :

  1. c[1]*x^n + c[2]*x^(n-1) + ... + c[n]*x + c[n+1] = 0

Un vecteur avec zéro élément est renvoyé si l'équation n'a pas de solution (roots(1), par exemple). NULL est renvoyé si elle a un nombre infini de solutions (roots(0), par exemple). Sinon, le vecteur renvoyé contient toutes les solutions.

Fonction :

spline ( a; x )

Cette fonction calcule ou évalue des interpolations splines cubiques naturelles pour des données données. Si elle est appelée avec un paramètre, a, une spline pour les points du vecteur a est calculée. Les éléments de a donnent les ordonnées ; les étiquettes de a donnent les abscisses. Si a n'a pas d'étiquettes numériques, alors les nombres naturels de un à la longueur de a sont supposés. Dans tous les cas, le vecteur a est trié par rapport à ses étiquettes ; elles doivent être uniques.

Si spline est appelée avec deux paramètres, a et x, alors la spline a (ou une interpolation spline de a, si a n'est pas une spline) est évaluée aux valeurs d'abscisse données par le vecteur x.

Fonction :

trapz ( y )

Cette fonction calcule une approximation de l'intégrale de y en utilisant la méthode trapézoïdale. Si y a des étiquettes numériques, elles sont utilisées comme abscisses ; sinon, l'espacement des unités est supposé. Pour que le résultat ait un sens, vous souhaiterez probablement que les étiquettes soient dans un ordre croissant monotone.

À titre d'exemple, utilisez trapz pour calculer l'intégrale définie de 1/x de 1 à 2 :

x = linspace (1; 2; 11);
y = label (1/x; x);
trapz (y)
                0.6938
log(2)-log(1)
                0.6931

Entrée/sortie de base

Fonction :

close ( file )

La fonction close ferme le fichier spécifié. Le nom du fichier doit être donné exactement tel qu'il était lors de son ouverture. (Les espaces sont significatifs.) Toutes les données mises en mémoire tampon sont vidées.

Fonction :

digits ( n )

La fonction digits peut être utilisée pour spécifier le nombre de chiffres qu'Algae utilise lors de l'affichage de nombres réels et complexes. Cela s'applique à la fonction print et aux «instructions d'affichage» (celles avec des points d'interrogation ou des terminaisons de nouvelle ligne). Le paramètre n spécifie le nombre de chiffres. Si n est NULL, aucune action n'est effectuée.

La fonction renvoie le nombre de chiffres utilisés. Par défaut, Algae utilise 4 chiffres.

Voici un exemple d'interaction, avec une entrée utilisateur précédée du prompt ">" :

> digits ()      # la valeur par défaut
          4
> acos (-1)      # pi, à 4 chiffres significatifs
          3.142
> digits (20);   # défini sur 20 chiffres
> acos (-1)      # pi, jusqu'à 20 chiffres (mais précis seulement à 17)
          3.1415926535897931000

Cette fonction définit simplement la variable globale $digits, vous pouvez donc faire la même chose en lui affectant directement.

Voir aussi print.

Fonction :

fread ( file; length; type)

La fonction fread lit les données d'un fichier binaire dans un tableau numérique. Il s'agit d'une routine de bas niveau, et elle nécessite que vous connaissiez précisément le format des données lues. Pour lire les propres fichiers binaires d'Algae (ceux écrits avec put), voir get.

Le paramètre file (un scalaire de caractères) est le nom du fichier. Comme pour tout nom de fichier, si son premier caractère est un point d'exclamation, le reste de la chaîne de caractères est donné à l'interpréteur de commande comme filtre. Si file est NULL, l'entrée standard est lue.

Le paramètre length (un scalaire entier) donne le nombre d'éléments à lire. S'il est NULL, le fichier entier est lu. Sinon, il doit s'agir d'un entier non négatif. Un vecteur est renvoyé contenant les données lues. Si fread atteint la fin du fichier avant d'avoir lu les éléments length, le vecteur qu'il renvoie contiendra moins de éléments length.

Le paramètre type est un tableau facultatif ; les noms de ses membres spécifient le type de données à lire et, implicitement, le type du tableau renvoyé. (Les valeurs des membres de cette table sont sans importance ; seuls leurs noms sont importants.) Ces noms peuvent inclure n'importe lequel des types du langage C :

Type de données Description
char Chacun est converti en un entier Algae.
int Identique à un entier Algea.
float Chacun est moulé sur un réel d'Algea.
double Identique à un réel d'Algea.

Les qualificateurs de type du langage C sont également acceptés dans le type :

Type de données Description
long Qualificateur pour les types int et double. Les deux sont convertis en réel.
short Qualificateur pour int. Convertit en entier.
signed Qualificateur pour char et int. Convertit en entier.
unsigned Qualificateur pour char et int. Un char non signé est converti en entier, tandis qu'un int non signé est converti en réel.

Les combinaisons n'étant pas autorisées en C (comme le double non signé) ne sont pas autorisées ici non plus. Si le type est NULL ou vide, le double est supposé.

Outre les qualificateurs de type de langage de programmation C venant d'être décrits, les qualificateurs spéciaux suivants sont également acceptés :

Qualificateur Description
big Spécifie l'ordre des octets dit «big endian».
little Spécifie l'ordre des octets dit «little endian».
ieee Spécifie le format à virgule flottante binaire IEEE 754.

Fonction :

fprintf ( file; format; ... )

La fonction fprintf affiche la sortie formatée dans un fichier. Le paramètre format est une chaîne de caractères contenant deux types d'objets : les caractères et les spécifications de conversion. Les caractères sont affichés directement ; les spécifications de conversion entraînent le formatage et l'affichage du paramètre suivant.

Les spécifications de conversion sont introduites à l'aide du signe de pourcentage «%». Bien que des extensions soient prévues, les spécifications de conversion sont actuellement identiques à celles de la fonction «fprintf» du langage de programmation C ANSI.

Si le premier caractère de fichier est un point d'exclamation, le reste de fichier est donné à l'interpréteur de commande comme filtre auquel la sortie affichée de fprintf est envoyée. Par exemple, la commande fprintf("!sort";"a\nc\nb\n");close("!sort"); envoie «a», «c» et «b», chacun sur une ligne distincte, à la fonction de tri du système, les triant et les affiche ensuite vraisemblablement. Si fichier est NULL, stdout est utilisé.

Voir également message, print, printf, sprintf et put.

Fonction :

fwrite ( file; v; type )

La fonction fwrite écrit des données binaires dans un fichier à partir d'un tableau numérique. Il s'agit d'une routine de bas niveau, et elle nécessite que vous spécifiiez précisément le format des données à écrire. Pour écrire une entité à utiliser dans Algae, vous souhaiterez probablement utiliser put à la place.

Le paramètre file (un scalaire de caractères) est le nom du fichier. Comme pour tout nom de fichier, si son premier caractère est un point d'exclamation, le reste de la chaîne est transmis à l'interpréteur de commande sous forme de filtre. Si file est NULL, les données sont écrites sur la sortie standard.

Les données à écrire sont données dans le paramètre v, un vecteur numérique.

Le paramètre type est une table facultative ; les noms de ses membres spécifient le type de données à écrire. (Les valeurs des membres de cette table sont sans importance ; seuls leurs noms sont importants.) Ces noms peuvent inclure n'importe lequel des types et qualificateurs du langage de programmation C, ainsi que quelques autres. Voir fread pour plus de détails.

Fonction :

message ( fmt; ... )

La fonction message permet d'écrire des messages d'erreur sur stderr. Ses paramètres sont exactement comme printf, sauf qu'un maximum de 10 paramètres est autorisé. Le message écrit comprend les noms du programme et du fichier ainsi que le numéro de ligne.

Voir aussi printf.

Fonction :

print ( x; file )

La fonction print affiche son paramètre x dans un fichier nommé par file. Cette sortie passe par le même formatage que celui utilisé par Algae pour afficher des entités à l'écran. En particulier, la variable $term_width contrôle la largeur de cette sortie et la variable $digits spécifie le nombre de chiffres significatifs affichés pour les nombres réels et complexes.

Si file est NULL, la sortie est écrite sur stdout.

Voir aussi digits, fprintf, printf, sprintf et put.

Fonction :

printf ( format; ... )

La fonction printf affiche une sortie formatée sur stdout. C'est exactement la même chose que d'appeler fprintf avec NULL comme premier paramètre.

Voir aussi fprintf, message, print, put et sprintf.

Fonction :

read ( file )

Cette fonction lit une ligne de texte et la renvoie sous forme de chaîne de caractères. Le paramètre de fichier peut être un nom de fichier ou un tube; voir fprintf pour plus de détails. Si fichier est NULL, le texte est lu à partir de l'entrée standard.

Lorsque read atteint la fin du fichier, il renvoie NULL.

Voir aussi get et readnum.

Fonction :

readnum ( shape; file )

Cette fonction lit les nombres réels à partir d'un fichier nommé file. Le vecteur shape spécifie la forme de la sortie. Si shape est NULL ou a une longueur de zéro, un scalaire est renvoyé. Si shape a une longueur de un, alors un vecteur avec des éléments shape[1] est renvoyé. Si shape a deux éléments, alors une matrice est renvoyée avec des lignes shape[1] et des colonnes shape[2].

Les valeurs sont lues à partir de file, ou de stdin si file est NULL ou n'est pas donné. Le symbole `#' est spécial - lui et tous les caractères restants sur une ligne sont ignorés. Si la fin de file est atteinte avant que le nombre spécifié de valeurs ne soit lu, alors le résultat est rempli de zéros. Après un appel à readnum, le nombre de valeurs réellement lues est contenu dans la variable $read.

Par exemple, disons que vous avez un fichier appelé `jnk' contenant les éléments suivants :

# cette ligne est ignorée - les nombres comme 1,23 sont ignorés
les deux premiers nombres sont 42 et 99.
3.14 est le suivant

Dans l'interaction suivante, nous lisons les nombres du fichier dans une matrice :

> x = readnum (2,4; "jnk")?
              [         42.00        99.00        3.140        0.000 ]
              [         0.000        0.000        0.000        0.000 ]
> $read?
              3
> readnum (3; "jnk")?
              (        0.000,       0.000,       0.000 )

Comme vous pouvez le voir, tout ce qui ne ressemble pas à un nombre est simplement ignoré. La fonction readnum a trouvé trois nombres et a rempli le reste de la matrice avec des zéros. La variable globale $read a été définie sur 3 - le nombre de valeurs réellement lues.

Les appels ultérieurs à readnum avec le même nom de fichier continuent simplement la lecture à partir de la dernière position du fichier. Dans la dernière instruction de l'exemple précédent, aucun autre nombre n'a été trouvé, le vecteur a donc été rempli de zéros. Pour relire depuis le début du fichier, vous devez d'abord fermer le fichier avec la fonction close.

La fonction readnum reconnaît les entiers et les nombres à virgule flottante. Un nombre à virgule flottante se compose d'une partie entière éventuellement signée, d'un point décimal, d'une partie fractionnaire, d'un «e» ou «E» et d'un exposant entier éventuellement signé. Tous les exemples suivants sont reconnus comme des nombres : «1», «-1,2», «1e2», «-1,e2», «.1e2», «-1,2e3» et «1,2e-3».

Utilisateurs de Fortran, prenez note ! Un nombre Fortran à double précision tel que «1,23D4» ne sera pas lu par readnum comme un nombre unique. Le caractère «D» n'est pas reconnu comme faisant partie d'un nombre à virgule flottante, donc readline le lira comme les deux nombres «1,23» et «4».

Fonction :

sprintf ( format; ... )

La fonction sprintf écrit une sortie formatée dans un scalaire de caractères. Elle fonctionne de la même manière que printf, sauf que la sortie est renvoyée au lieu d'être affichée. Par exemple, x=sprintf("y=%d";1) place la chaîne de caractères "y=1" dans le scalaire x.

Voir aussi fprintf, printf et put.

Fonction :

tmp_file ( )

La fonction tmp_file crée un fichier temporaire et renvoie son nom. Ce fichier sera automatiquement supprimé à la fermeture d'Algae.

Par défaut, Algae écrit les fichiers temporaires dans le répertoire `/tmp'. Vous pouvez remplacer cela par une variable d'environnement appelée TMPDIR. Par exemple, si vous utilisez l'interpréteur de commande Bourne et que vous mettez les lignes :

TMPDIR=/usr/tmp
export TMPDIR

dans votre fichier `~/.profile', Algae placera alors ses fichiers temporaires dans le répertoire `/usr/tmp'.

Cette fonction ne crée pas seulement le fichier, mais l'ouvre également pour la sortie. Si vous souhaitez lire le fichier temporaire, vous devez d'abord le fermer. (Bien sûr, vous devrez d'abord vous arranger pour y mettre quelque chose.) Notez que les fichiers temporaires ne sont pas supprimés lorsqu'ils sont fermés, mais seulement lorsqu'Algae se ferme.

Entité d'entrée/sortie

Fonction :

get ( file )

La fonction get lit une entité Algae à partir d'un fichier binaire nommé file. Si aucun paramètre n'est donné, l'entrée standard est utilisée. Utilisez cette fonction pour lire les fichiers écrits avec put. Le nom de fichier peut spécifier un tube ; voir fprintf pour plus de détails.

NULL est renvoyé si une erreur se produit lors de la lecture du fichier ; sinon, get renvoie l'entité lue.

Fonction :

getdyn ( fname )

Cette fonction lit les matrices du fichier fname de DYNASTY. (DYNASTY est le nom d'un progiciel utilisé chez Boeing pour l'analyse dynamique.) Une table est renvoyée, contenant les matrices comme membres.

Le nom du fichier peut spécifier un canal ; voir fprintf pour plus de détails.

Fonction :

getmat ( fname )

La fonction getmat lit les matrices à partir d'un fichier binaire MATLAB nommé fname. Elle renvoie les matrices dans une table.

Le nom de fichier peut spécifier un canal ; voir fprintf pour plus de détails.

Notez que getmat n'affecte pas les matrices à la table de symboles globale comme le fait la fonction «load» de MATLAB. Pour ce faire, vous pouvez utiliser quelque chose comme ce qui suit :

  1. Load = function (fname)
  2. {
  3.   local (t; n);
  4.   t = getmat (fname);
  5.   for (n in members (t))
  6.   {
  7.     $$.(n) = t.(n);
  8.   }
  9. };

La fonction getmat lit le format «fichier MAT de niveau 1» de MATLAB v.4. MATLAB peut lire et écrire dans ce format, mais son format par défaut pour l'écriture est désormais le niveau 2. L'utilisation du nouveau format nécessiterait de se connecter à leurs bibliothèques, ce qui signifie que vous auriez besoin d'avoir MATLAB sur cette machine. Nous nous en tiendrons à l'ancien format.

L'une des conséquences malheureuses de l'utilisation de l'ancien format de fichier est que les matrices ne peuvent pas être écrites sous forme clairsemée. Pour contourner ce problème, convertissez la matrice en forme de coordonnées (qui est dense) dans MATLAB, puis remettez-la sous forme clairsemée dans Algae avec la fonction mksparse.

Voir également get, put et putmat.

Fonction :

load ( fname )

La fonction load lit une table à partir d'un fichier nommé fname et affecte ses membres en tant que variables globales. Cela peut être utilisé, par exemple, pour restaurer une session Algae ayant été sauvegardée avec la fonction save.

Si une erreur se produit lors de la lecture du fichier, load renvoie 0 ; sinon, elle renvoie 1.

Voir également get, put et save.

Fonction :

put ( x; fname )

La fonction put écrit x dans un fichier binaire nommé fname (ou sur la sortie standard si fname est NULL). Ce fichier binaire peut être lu avec get. Le nom de fichier peut spécifier un tube ; voir fprintf pour plus de détails.

NULL est renvoyé si une erreur se produit lors de l'écriture du fichier ; sinon, un 1 est renvoyé.

Fonction :

putdyn ( x; fname )

Cette fonction écrit les membres de la table x dans un fichier DYNASTY nommé fname. (DYNASTY est le nom d'un progiciel utilisé chez Boeing pour l'analyse dynamique.) Le nom du fichier peut spécifier un canal ; voir fprintf pour plus de détails.

Le fichier n'est pas fermé lorsque putdyn se termine, donc les écritures suivantes dans le même fichier ajouteront des données à la fin de celui-ci, sauf si vous le fermez au préalable. Sur certaines machines, cela peut être utilisé pour construire un fichier DYNASTY complet avec plusieurs appels différents à putdyn. L'inconvénient, cependant, est que le format de fichier DYNASTY ne le permet pas sur toutes les machines.

Fonction :

putmat ( t; fname )

La fonction putmat écrit une table de matrices t dans un fichier binaire MATLAB nommé fname. Le nom de fichier peut spécifier un tube ; voir fprintf pour plus de détails.

NULL est renvoyé si une erreur se produit lors de l'écriture du fichier ; sinon, un 1 est renvoyé.

Les membres NULL dans t sont ignorés ; sinon, chaque membre est converti en matrice si nécessaire, puis écrit dans le fichier.

La fonction putmat écrit dans le format MATLAB v.4 «Fichier MAT de niveau 1». MATLAB peut lire et écrire dans ce format, mais sa valeur par défaut pour l'écriture est désormais le niveau 2. L'utilisation du nouveau format nécessiterait de créer un lien vers leurs bibliothèques, ce qui signifie que vous auriez réellement besoin d'avoir MATLAB sur cette machine. Nous nous en tiendrons à l'ancien format.

Une conséquence malheureuse de l'utilisation de l'ancien format de fichier est que les matrices ne peuvent pas être écrites sous forme éparse. Pour contourner ce problème, utilisez la fonction exsparse pour convertir la matrice en forme de coordonnées (qui est dense), puis remettez-la en forme clairsemée dans MATLAB.

Voir aussi get, getmat et put.

Fonction :

save ( fname )

La fonction save écrit toutes les variables globales non NULL sous forme de table dans un fichier nommé fname. Cela peut être utilisé, par exemple, pour enregistrer une session Algae que vous souhaitez redémarrer ultérieurement à l'aide de la fonction load.

NULL est renvoyé si une erreur se produit lors de l'écriture du fichier ; sinon, save renvoie 1.

Voir aussi get, load et put.

Exécution

Fonction :

autosrc ( name; file )

Cette fonction crée une fonction autosrc nommée name. Lorsque cette nouvelle fonction est appelée ultérieurement, elle se remplace par une définition qu'elle lit en appelant la fonction src avec le nom de fichier fichier. De cette façon, vous pouvez reporter la lecture de la définition d'une fonction jusqu'à ce qu'elle soit réellement appelée.

Si fichier est NULL, alors autosrc utilise la valeur de nom pour le nom de fichier.

Par exemple, considérez le code suivant :

  1. autosrc ("yow");
  2. yow ();

La première ligne définit une fonction autosrc nommée yow. Lorsque yow est appelé sur la deuxième ligne, il lit la définition réelle de yow en appelant src avec le nom de fichier "yow". Il appelle ensuite son remplacement (avec les mêmes paramètres, bien sûr).

L'implémentation actuelle de autosrc limite le nombre d'arguments à 10. (C'est une restriction désagréable, mais si vous avez besoin d'autant de paramètres, vous devriez peut-être utiliser une table à la place.) Un zéro renvoyé indique le succès.

Fonction :

builtin ( file; symbol )

Sur les machines prenant en charge la liaison dynamique, cette fonction crée une nouvelle fonction intégrée en établissant un lien vers un objet partagé nommé par fichier et en localisant le symbole nommé par symbol.

Supposons que vous ayez un vieux code Fortran calculant vos chances d'être frappé par une comète. Vous pouvez écrire un enveloppe C pour cela, les lier en tant qu'objet partagé, utiliser builtin pour l'attacher, et voilà ! c'est une fonction intégrée.

Contrairement à d'autres fonctions d'Algae traitant des fichiers, builtin n'accepte pas les noms de fichiers spéciaux de type «bang». (Ce sont des noms de fichiers commençant par un point d'exclamation et sont donnés au interpréteur de commande sous forme de commande.)

Il n'est pas difficile de créer des objets partagés pour builtin, mais il n'existe actuellement aucune documentation à ce sujet. Peut-être pouvez-vous trouver un code à imiter.

Fonction :

cd ( path )

La fonction cd remplace le répertoire par défaut actuel par celui spécifié par le chemin scalaire de caractères. Si path est NULL, le répertoire est remplacé par celui donné par la variable d'environnement HOME.

Une exception est levée si une erreur se produit ; sinon, cd renvoie l'entier 1.

Fonction :

eval ( s )

La fonction eval évalue la chaîne de caractères s en tant qu'expression et renvoie sa valeur. Les références de variables, le cas échéant, ont une portée globale. Par exemple, considérons l'interaction suivante :

> x = 0.5;
> str = "sin(x)";
> eval (str)
                0.4794
> x = 1.0;
> eval (str)
                0.8415

Bien que la valeur de str reste «sin(x)», le résultat de eval(str) change lorsque la valeur de x change.

Contrairement à sa place prépondérante dans certains langages de programmation matricielle, eval est rarement nécessaire dans Algae. La plupart des exemples de son utilisation sont plutôt artificiels. Voici un code évaluant une expression saisie par l'utilisateur :

  1. x = eval (read ("!echo -n \"expression? \" 1>&2 ; head -1"))

Une utilisation de eval n'étant peut-être pas aussi artificielle consiste à créer une fonction dans une fonction, ce que vous ne pouvez pas faire directement dans Algae. Voici un exemple :

  1. add_const = function (c)
  2. {
  3.   return eval (sprintf ("function (x) { return x+%g; }"; c));
  4. };

Cela pourrait alors être utilisé comme suit :

> ten_more = add_const( 10 );
> ten_more(1)?
                11

L'erreur la plus courante avec eval est probablement de lui donner une instruction au lieu d'une expression. Si c'est vraiment ce que vous voulez faire, utilisez plutôt la fonction exec.

N'oubliez pas non plus que toutes les références de variables sont à portée globale. Par exemple, la fonction :

  1. function( a; b ) { return eval( "a + b" ); }

renvoie la somme des variables globales a et b ; elle ignore complètement les arguments de la fonction, car ce sont des variables locales.

Voir aussi exec.

Fonction :

exception ( )

Cette fonction «génère une exception», ce qui signifie qu'Algae renvoie une erreur. Si l'exécution est interactive, le contrôle revient à l'utilisateur. Sinon, Algae se ferme.

Fonction :

exec ( s )

La fonction exec permet à Algae d'analyser et d'exécuter les instructions Algae contenues dans la chaîne de caractères s. L'exécution commence à la portée globale, même si exec est appelé à partir d'une fonction. Elle renvoie un entier négatif si une erreur se produit, et zéro dans le cas contraire.

Voir aussi eval et source.

Fonction :

exit ( status )

Cette fonction termine Algae. Le paramètre optionnel status spécifie l'état de sortie renvoyé par Algae. Sur la plupart des plates-formes informatiques, l'état de sortie doit être un petit entier positif. Le paramètre status de exit doit être un scalaire numérique. Si exit est appelé avec n'importe quel autre paramètre, Algae renvoie 0 comme état de sortie.

Un appel à exit n'est pas obligatoire dans vos programmes Algae. Algae se termine lorsqu'il atteint la fin de son entrée, renvoyant l'état de sortie 0. Si une erreur provoque l'arrêt d'Algae, l'état de sortie 1 est renvoyé.

Fonction :

file ( )

La fonction file renvoie le nom du fichier à partir duquel les instructions sont actuellement exécutées.

Fonction :

get_path ( env; def )

La fonction get_path renvoie une liste de chemins, à utiliser dans la recherche de fichiers. Le paramètre env, s'il n'est pas NULL, donne le nom d'une variable d'environnement contenant une liste de chemins séparés par deux points. Le paramètre def donne une valeur par défaut, au cas où env n'est pas donné ou n'existe pas.

Voir aussi search_path et src.

Fonction :

getenv ( ename )

La fonction getenv renvoie un scalaire de caractères contenant la valeur de la variable d'environnement nommée par ename. Si aucune variable de ce type n'existe, NULL est renvoyé.

Fonction :

line ( )

La fonction line renvoie le numéro de ligne à partir duquel elle est appelée.

Fonction :

provide ( feature )

Une fonctionnalité est simplement un nom représentant une collection particulière de fonctions ou d'autres entités. Un programme annonce qu'une fonctionnalité est présente en appelant la fonction provide avec feature, le nom de cette fonctionnalité. Cela signifie que les fonctionnalités associées à feature ont été mises à disposition d'autres programmes Algae.

Les programmes nécessitant une fonctionnalité particulière peuvent rechercher le fichier approprié avec la fonction require.

Le paramètre feature doit être un scalaire de caractères. Il est ajouté à la variable globale $features s'il n'est pas déjà présent dans ce vecteur. La fonction provide renvoie feature.

Fonction :

require ( feature; filename )

Une feature est simplement un nom représentant une collection particulière de fonctions ou d'autres entités. Un programme ayant besoin de la collection peut s'assurer qu'elles sont définies en appelant require avec le nom de cette fonctionnalité. L'utilisation de fonctionnalités nommées simplifie la tâche de détermination de l'existence ou non des affectations requises.

La fonction require vérifie la fonctionnalité nommée feature dans la session Algae en cours ; si elle n'est pas présente, require lit le fichier source filename avec src. Si filename est NULL, la valeur de feature est utilisée comme nom de fichier.

Avant de terminer, le fichier source lu par require doit appeler la fonction provide, indiquant que la fonctionnalité souhaitée a été fournie. Une exception est levée si le fichier source ne peut pas être lu ou ne fournit pas la fonctionnalité nommée feature.

Fonction :

search_path ( fn; suffices; path )

La fonction search_path recherche un fichier dans les répertoires nommés dans path. Le nom du fichier commence par la chaîne de caractères donnée par fn, avec l'un des suffixes donnés par suffices.

Fonction :

source ( fname )

Cette fonction force Algae à analyser et exécuter le fichier nommé fname. L'exécution commence à l'échelle globale, même si la source est appelée à partir d'une fonction. Elle renvoie NULL en cas de problème lors de l'ouverture de fname, un entier négatif si une erreur d'analyse ou d'exécution se produit et zéro dans le cas contraire.

Le fichier est fermé après avoir été lu.

Voir également exec et sources.

Fonction :

sources ( fname )

La fonction sources permet à Algae d'analyser et d'exécuter les fichiers spécifiés. Le caractère scalaire fname est transmis via sh(1) à ls(1), de sorte que la génération de noms de fichiers est disponible et que plusieurs noms peuvent être donnés. Par exemple :

  1. sources( "*.A" );

source tous les fichiers se terminant par «.A» dans votre répertoire de travail. Vous pouvez cependant utiliser la fonction source pour effectuer cette opération comme suit :

  1. source( "!cat *.A" );

L'utilisation de sources est préférable car elle conserve les informations de fichier et de ligne correctes pour l'interpréteur.

La capacité «pipe» normalement disponible pour les fonctions d'entrées/sorties d'Algae n'est pas autorisée dans les sources. La substitution de commande fonctionne cependant, comme illustré ici :

  1. sources( "`find $HOME -name '*.A' -print`" );

Cet exemple répertorie tous les fichiers se terminant par «.A» trouvés dans n'importe quel sous-répertoire de votre répertoire personnel.

Fonction :

src ( filename )

La fonction src recherche et ouvre un fichier de code Algae, exécute les instructions qu'il contient à l'échelle globale, puis ferme le fichier. Cette fonction, plutôt que source ou sources, est destinée à être la méthode normale pour rechercher directement les fichiers source. Les autres fonctions pouvant être utilisées pour rechercher les fichiers source sont require et autosrc.

Pour trouver le fichier, src recherche d'abord un fichier nommé `filename.A', c'est-à-dire qu'il ajoute `.A' au nom donné par le paramètre filename. Si un fichier portant ce nom existe, il est sourcé ; sinon, src recherche un fichier nommé filename sans rien ajouter, et le source s'il existe.

Si filename est un nom de fichier relatif, tel que `foo' ou `foo/bar.A', src recherche le fichier à l'aide de la variable $src_path. Il ajoute filename à chacun des répertoires listés dans le vecteur de caractères $src_path (avec et sans le « .A ») et recherche le premier fichier qu'il trouve dont le nom correspond. Le répertoire par défaut actuel est essayé uniquement s'il est spécifié dans $src_path.

Aucune recherche de répertoire n'est effectuée si filename est un nom de fichier absolu. Les noms de fichiers commençant par «/», «./», «../» ou «~/» sont absolus. Si le nom de fichier commence par «~/», le tilde est remplacé par la valeur de la variable d'environnement HOME.

Un nom de fichier commençant par le caractère «!» est un tube ; le reste du nom de fichier est donné sous forme de ligne de commande de l'interpréteur de commande, dont la sortie standard est ensuite lue par src. Par exemple :

  1. src("!m4 foo.A")

exécute le fichier `foo.A' via le préprocesseur de macro m4 avant que src ne le lise.

Le vecteur $src_path est initialisé à partir de la variable d'environnement ALGAE_SRC_PATH, si elle existe. Il peut être modifié dans l'un des fichiers de démarrage `/usr/local/lib/algae/4.3.5/algae.A' ou `$HOME/.algae'.

La syntaxe de ALGAE_SRC_PATH est la même que celle de PATH pour l'interpréteur de commande ; les champs sont séparés par `:', et `.' est utilisé pour le répertoire par défaut actuel. Pour définir ALGAE_SRC_PATH dans l'interpréteur de commande Bourne, saisissez quelque chose comme ce qui suit :

export ALGAE_SRC_PATH
ALGAE_SRC_PATH=.:~/algae:/usr/local/lib/algae

L'exécution du code Algae dans filename commence à l'échelle globale. Par exemple, si le fichier source contient l'instruction unique x=1, l'affectation est effectuée sur la variable globale x, que src ait été appelé depuis une fonction ou non.

La fonction src génère une exception si filename est introuvable. Elle renvoie NULL s'il ne peut pas être ouvert, un entier négatif si une erreur d'analyse ou d'exécution se produit et 0 dans le cas contraire.

Fonction :

strip ( f )

La fonction strip supprime toutes les informations de fichier et de ligne de la fonction f donnée. L'analyseur inclut généralement ces informations afin que, par exemple, les messages d'erreur d'exécution puissent identifier la ligne sur laquelle ils se sont produits. Si une erreur se produit dans une fonction ayant été supprimée, l'erreur est alors attribuée à l'expression appelante.

Cette fonction peut également être utile en conjonction avec le profilage. Tout temps passé dans un appel à une fonction supprimée est imputé au fichier et à la ligne à partir desquels elle a été appelée.

Tous les membres de f restent inchangés en tant que membres de la valeur de retour.

Fonction :

system( s )

Cette fonction transmet la chaîne de caractères s au processeur de commandes pour exécution. Sur un système UNIX, par exemple, l'instruction system("ls") répertorie les fichiers du répertoire courant. Si l'appel réussit, l'état de sortie est renvoyé ; sinon, un -1 est renvoyé.

Outils spéciaux

Fonction :

npsol ( objective; start; constraints; options; state )

La fonction npsol utilise une méthode de programmation quadratique séquentielle pour minimiser une fonction objective donnée soumise à des contraintes données. Le domaine de la fonction objective est appelé «espace de conception» et les coordonnées de l'espace de conception sont appelées «variables de conception».

Cette fonction utilise le paquet NPSOL de routines Fortran développé et vendu par l'Université de Stanford. Votre version d'Algae n'a peut-être pas la fonction intégrée npsol; si ce n'est pas le cas, cela signifie probablement que vous n'avez pas de licence pour NPSOL ou qu'il y a eu un problème lors de son installation sur votre ordinateur.

La fonction npsol ne peut pas être appelée de manière récursive.

Le paramètre objective peut être soit une fonction, soit une table. S'il s'agit d'une fonction, elle est supposée prendre un paramètre, un vecteur de variables de conception, et renvoyer la valeur de l'objectif à ce stade. Si l'objectif est une table, il peut avoir les membres suivants :

Membre Description
objf Une fonction renvoyant la valeur de la fonction objective pour le vecteur de variables de conception donné comme premier paramètre. Si le membre params existe dans objective, il est alors passé comme second paramètre à objf.
objgrd Une fonction renvoyant les sensibilités de la fonction objective, c'est-à-dire les premières dérivées par rapport aux variables de conception. Ses paramètres sont les mêmes que pour objf.
params Ce membre, s'il existe, est passé comme deuxième paramètre à objf et objgrd, fournissant un moyen de passer des paramètres supplémentaires à ces fonctions.

Seul le membre objf est requis. Si les dérivées objectives ne sont pas fournies, vous devez vous assurer que derived_level est défini en conséquence.

Le paramètre start est un vecteur spécifiant le point de départ.

Le paramètre constraints est une table pouvant contenir l'un des membres suivants :

Membre Description
side_constraints Une matrice spécifiant les contraintes supérieures et inférieures sur les valeurs des variables de conception. Cette matrice comporte deux colonnes, la première colonne indiquant les limites inférieures et la seconde les limites supérieures. Si ce membre n'est pas fourni, une valeur par défaut est fournie en utilisant 1,0E10 comme «infini». Dans ce cas, vous devez savoir que NPSOL prendra ces valeurs littéralement si vous utilisez également l'option «infinite_bound» (dans les options) avec une valeur supérieure à 1,0E10.
linear_constraints Une table pouvant contenir tout ou partie des membres suivants :
Membre Description
coefficients Une matrice des coefficients de contrainte linéaire. La i-ème ligne contient les coefficients de la i-ème contrainte linéaire.
bounds Une matrice, comme side_constraints, qui donne les limites supérieure et inférieure des contraintes linéaires. Si elles ne sont pas fournies, des valeurs par défaut sont fournies comme avec side_constraints.
nonlinear_constraints Une table pouvant contenir tout ou partie des membres suivants :
Membre Description
values Soit une fonction calculant le vecteur des valeurs de la fonction de contrainte non linéaire au point donné, soit une table dans laquelle le membre conf est une fonction renvoyant les valeurs et congrd est une fonction renvoyant les gradients. Les gradients de contrainte, s'ils sont fournis, doivent être donnés sous forme de matrice dans laquelle les lignes correspondent aux contraintes et les colonnes correspondent aux variables de conception. Comme dans les objectifs, un membre appelé params peut également être inclus.
bounds Une matrice, comme side_constraints, donnant les limites supérieure et inférieure des contraintes non linéaires. Si elles ne sont pas fournies, les valeurs par défaut sont fournies comme avec side_constraints.
Si les dérivées de contrainte ne sont pas fournies, vous devez vous assurer que le paramètre derived_level est défini en conséquence.

Le paramètre options est un tableau pouvant contenir n'importe laquelle des options NPSOL valides. Par exemple, { hessian = "yes" } spécifie l'option correspondante dans NPSOL. Utilisez un trait de soulignement au lieu d'espaces entre les mots, comme dans { major_print_level = 1 }. Les options valides sont :

Option Description
central_difference_interval Si l'algorithme passe aux différences centrales parce que l'approximation des différences directes n'est pas suffisamment précise, cette valeur est utilisée comme intervalle de différence pour chaque variable.
cold_start
warm_start
Ces drapeaux contrôlent la spécification de l'ensemble de travail initial dans la procédure de recherche d'un point réalisable pour les contraintes et les limites linéaires, et dans le premier sous-problème QP suivant. Avec un démarrage à froid, le premier ensemble de travail est choisi par npsol en fonction des valeurs des variables et des contraintes au point initial. D'une manière générale, l'ensemble de travail initial comprendra des contraintes et des limites d'égalité ou des contraintes d'inégalité violant ou satisfaisant «presque» leurs limites dans la tolérance de collision. Avec un démarrage à chaud, l'utilisateur doit fournir la table d'état. Un démarrage à chaud sera avantageux si une bonne estimation de l'ensemble de travail initial est disponible, par exemple lorsque npsol est appelé à plusieurs reprises pour résoudre des problèmes connexes.
crash_tolerance Cette valeur est utilisée conjointement avec le paramètre facultatif cold_start, étant la valeur par défaut. Lors d'un démarrage à froid, l'algorithme QP dans npsol doit sélectionner un ensemble de travail initial. L'ensemble de travail initial comprendra, si possible, des limites ou des contraintes d'inégalité générales se situant dans la limite crash_tolerance de leurs limites. La valeur par défaut est 0,01. Si crash_tolerance est inférieur à zéro ou supérieur à un, la valeur par défaut est utilisée.
derivative_level Cette valeur indique les dérivées objectives et contraintes fournies par l'utilisateur. Les choix sont les suivants :
Valeur Description
0 Aucune dérivée objective ni aucune dérivée de contrainte ne sont fournies.
1 Les dérivées objectives sont fournies par la fonction objgrd dans le paramètre objective. Les dérivées de contrainte ne sont pas fournies.
2 Les dérivées de contraintes non linéaires sont fournies par la fonction congrd dans les contraintes d'argument. Les dérivées objectives ne sont pas fournies.
3 Les dérivées objectives sont fournies par la fonction objgrd dans le paramètre objective, et les dérivées de contraintes non linéaires sont fournies par la fonction congrd dans le paramètre constraints.
La valeur 3 est la valeur par défaut et doit être utilisée autant que possible, car npsol est plus fiable et sera généralement plus efficace lorsque toutes les dérivées sont exactes.

Si derived_level est 0 ou 2, alors npsol estimera les gradients objectifs à l'aide de différences finies. Le calcul des approximations aux différences finies augmente généralement le temps d'exécution total, car un appel à la fonction objective est requis pour chaque contrainte. De plus, une précision moindre peut être atteinte dans la solution.

Si derived_level est 0 ou 1, npsol approximera les gradients de contrainte. Un appel à la fonction de contrainte est requis pour chaque variable. Parfois, les différences centrales sont utilisées plutôt que les différences directes, auquel cas deux fois plus d'appels aux fonctions objective et de contrainte sont nécessaires. Le passage aux différences centrales n'est pas sous le contrôle de l'utilisateur.
difference_interval Cette valeur définit un intervalle utilisé pour estimer les gradients par différences finies dans les circonstances suivantes : (1) pour vérifier les gradients objectifs et de contrainte, et (2) pour estimer les dérivées objectifs ou de contrainte. Si aucun intervalle de différence n'est spécifié par l'utilisateur, un intervalle de différence finie sera calculé automatiquement pour chaque variable par une procédure qui nécessite jusqu'à six appels des fonctions objectifs et de contrainte pour chaque composant. Cette option est recommandée si la fonction est mal dimensionnée ou si l'utilisateur souhaite que npsol détermine les éléments constants dans les gradients objectifs et de contrainte.
feasibility_tolerance Cette valeur définit les violations absolues maximales acceptables dans les contraintes linéaires et non linéaires à un point « faisable » ; autrement dit, une contrainte est considérée comme satisfaite si sa violation ne dépasse pas cette valeur. La valeur par défaut est la racine carrée de la précision de la machine.
function_precision Cette valeur est destinée à être une mesure de la précision avec laquelle les fonctions objectif et contrainte peuvent être calculées. Elle agit comme une précision relative lorsque la magnitude est grande et comme une précision absolue lorsque la magnitude est petite. Par exemple, si la fonction objectif est généralement de l'ordre de 1000 et que les 6 premiers chiffres sont connus pour être corrects, function_precision doit être défini sur 1,0E-6. En revanche, si la fonction objectif est généralement de l'ordre de 1,0E-4 et que les 6 premiers chiffres sont connus pour être corrects, function_precision doit être défini sur 1,0E-10. Le choix de function_precision peut être assez compliqué pour les problèmes mal dimensionnés. La valeur par défaut est la précision machine élevée à la puissance 0,9 ; elle convient à la plupart des fonctions simples étant calculées avec une précision totale. Cependant, lorsque la précision des valeurs de fonction calculées est connue pour être nettement inférieure à la précision totale, la valeur function_precision doit être suffisamment grande pour que npsol ne tente pas de faire la distinction entre les valeurs de fonction différant de moins que l'erreur inhérente au calcul.
hessian Cette option doit être soit «yes» soit «no». (La valeur par défaut est «no»). Cette option contrôle le contenu de la matrice R dans l'état. L'utilisateur doit définir hessian sur «yes» si la table d'état renvoyée doit être utilisée pour un démarrage à chaud ultérieur.
infinite_bound_size Si cette valeur est supérieure à zéro, elle définit la borne «infinite» dans la définition des contraintes du problème. Toute borne supérieure supérieure ou égale à cette valeur sera considérée comme l'infini positif. Toute borne inférieure inférieure ou égale à la valeur négative de cette valeur sera considérée comme l'infini négatif. La valeur par défaut est 1,0E10.
infinite_step_size Cette valeur spécifie l'ampleur du changement des variables étant traité comme une étape vers une solution non bornée. Si le changement d'une variable au cours d'une itération dépasse la valeur de infinite_step_size, la fonction objective est considérée comme non bornée en dessous de la zone réalisable. La valeur par défaut est la plus grande de infinite_bound_size et 1.0E10.
iteration_limit Cette valeur spécifie le nombre maximal d'itérations majeures autorisées avant la fin.
linear_feasibility_tolerance
nonlinear_feasibility_tolerance
Ces valeurs définissent les violations absolues maximales acceptables dans les contraintes linéaires et non linéaires à un point « faisable ». Une contrainte est considérée comme satisfaite si sa violation ne dépasse pas cette valeur. La valeur par défaut pour les deux options est la racine carrée de la précision de la machine.

A l'entrée dans npsol, une procédure itérative est exécutée afin de trouver un point satisfaisant les contraintes linéaires et les limites des variables dans l'intervalle linear_feasibility_tolerance. Toutes les itérations suivantes satisferont les contraintes linéaires dans la même tolérance, à moins que cette valeur ne soit comparable à l'intervalle de différences finies.

Pour les contraintes non linéaires, nonlinear_feasibility_tolerance définit la plus grande violation de contrainte acceptable à un point optimal. Étant donné que les contraintes non linéaires ne sont généralement pas satisfaites avant l'itération finale, cette valeur agit comme un critère de fin partielle pour la séquence itérative.

Ces tolérances doivent refléter la précision des contraintes correspondantes, par exemple, si les variables et les coefficients dans les contraintes linéaires sont de l'ordre de l'unité, et que ces derniers sont corrects à environ 6 décimales, il serait approprié de spécifier linear_feasibility_tolerance comme 1,0E-6.
linesearch_tolerance Cette valeur contrôle la précision avec laquelle une étape effectuée au cours de chaque itération se rapproche d'un minimum de la fonction de mérite le long de la direction de recherche. Plus la valeur est petite, plus la recherche de ligne est précise. La valeur par défaut est de 0,9 ; elle demande une recherche imprécise convenant à la plupart des problèmes, en particulier ceux qui présentent des contraintes non linéaires.
S'il existe des contraintes non linéaires, une recherche plus précise peut être appropriée lorsqu'il est souhaitable de réduire le nombre d'itérations majeures, par exemple si la fonction objective est peu coûteuse à évaluer ou si les gradients ne sont pas spécifiés.
list Si cet indicateur est donné, toutes les options et leurs valeurs sont affichées.
print_level Cette valeur contrôle la quantité de sortie affichée produite par les itérations principales de npsol. Les niveaux sont les suivants :
Valeur Description
0 Aucune sortie. Il s'agit de la valeur par défaut.
1 La solution finale uniquement.
5 Une ligne de sortie pour chaque itération majeure, mais pas de solution finale.
10 La solution finale et une ligne de sortie pour chaque itération.
20 À chaque itération majeure, la fonction objective, la norme euclidienne des violations de contraintes non linéaires, la valeur des contraintes non linéaires, les valeurs des contraintes linéaires et les valeurs courantes des variables.
minor_iteration_limit Cette valeur spécifie le nombre maximal d'itérations pour la phase d'optimalité de chaque sous-problème QP.
minor_print_level Cette valeur contrôle la quantité d'impression produite par les itérations mineures de npsol. Les niveaux sont les suivants :
Valeur Description
0 Aucune sortie. Il s'agit de la valeur par défaut.
1 La solution QP finale.
5 Une ligne de sortie pour chaque itération mineure, mais pas de solution QP finale.
10 La solution QP finale et une ligne de sortie pour chaque itération mineure.
20 À chaque itération mineure, les estimations actuelles des multiplicateurs QP, l'estimation actuelle de la direction de recherche QP, les valeurs de contrainte QP et l'état de chaque contrainte QP.
optimality_tolerance Cette valeur spécifie la précision avec laquelle l'utilisateur souhaite que l'itération finale se rapproche d'une solution du problème. En gros, elle indique le nombre de chiffres corrects souhaités dans la fonction objective à la solution. Par exemple, si optimality_tolerance est 1,0E-6 et que npsol se termine avec succès, la valeur finale de la fonction objective doit avoir environ 6 chiffres corrects. La fonction npsol se terminera avec succès si la séquence itérative est jugée comme ayant convergé et que le point final satisfait aux conditions d'optimalité du premier ordre.
verify_level Cette valeur fait référence aux contrôles aux différences finies sur les gradients calculés par la fonction utilisateur objgrd et congrd. Elle peut prendre l'une des valeurs suivantes :
Valeur Description
-1 Aucun contrôle n'est effectué.
0 Effectuez simplement une vérification très peu coûteuse, impliquant un appel à la fonction objectif et un appel à la fonction de contrainte.
1 Effectuez un contrôle fiable mais coûteux sur les gradients objectifs.
2 Effectuer une vérification fiable mais coûteuse des gradients de contraintes.
3 Effectuez des vérifications fiables mais coûteuses sur les gradients objectifs et de contrainte.
Ces vérifications sont recommandées chaque fois qu'une nouvelle routine de fonction est développée.

Le paramètre state n'est utilisé que lorsque l'option NPSOL "warm_start" est demandée. Il peut être obtenu à partir du retour d'un appel précédent à npsol. Ses membres sont :

Membre Description
ISTATE Un vecteur décrivant l'état des contraintes.
CLAMDA Les estimations du multiplicateur de Lagrange pour les contraintes non linéaires.
R L'Hessien factorisé de la fonction lagrangienne.

La fonction npsol renvoie une table contenant les membres suivants :

Membre Description
objective La valeur de la fonction objective à l'itération finale.
solution Le vecteur de solution (ou estimation finale) du problème.
inform La valeur INFORM (indicateur de réussite/erreur) renvoyée par NPSOL. Les possibilités sont les suivantes :
Valeur Description
0 Les itérations ont convergé vers un point satisfaisant les conditions d'optimalité du premier ordre avec la précision demandée par le paramètre optionnel optimality_tolerance, c'est-à-dire que le gradient projeté et les résidus de contrainte active sont négligeables. (Succès.)
1 L'itération finale satisfait aux conditions d'optimalité du premier ordre avec la précision requise, mais la séquence d'itérations n'a pas encore convergé. NPSOL a été arrêté car aucune amélioration supplémentaire n'a pu être apportée à la fonction de mérite. (Succès probable.)
2 Aucun point réalisable n'a pu être trouvé pour les contraintes et les limites linéaires. Le problème n'a pas de solution réalisable.
3 Aucun point réalisable n'a pu être trouvé pour les contraintes non linéaires. Le problème peut ne pas avoir de solution réalisable.
4 Le nombre limite d'itérations, déterminé par le paramètre facultatif major_iteration_limit, a été atteint.
6 Le point actuel ne satisfait pas les conditions d'optimalité du premier ordre et aucun point amélioré pour la fonction de mérite n'a pu être trouvé lors de la recherche de ligne finale.
7 Les dérivées fournies par l'utilisateur de la fonction objective et/ou des contraintes non linéaires semblent être incorrectes.
9 Un paramètre d'entrée n'est pas valide.
iter Le nombre d'itérations majeures effectuées.
state Le tableau d'état décrit ci-dessus.

Fonction :

plot ( ... )

Les fonctions plot, splot, replot et unplot fournissent une interface au programme gnuplot pour tracer des données. Utilisez plot pour tracer des lignes en deux ou trois dimensions ; splot pour tracer des surfaces en trois dimensions.

Pour utiliser efficacement ces fonctions de traçage, vous aurez probablement besoin d'une certaine familiarité avec les commandes gnuplot. Par exemple, pour ajouter un titre à un tracé existant, vous devez taper quelque chose comme replot("set title 'De bonnes choses'").

La fonction plot accepte jusqu'à trois paramètres. Si l'un ou les deux premiers paramètres sont (ou peuvent être convertis en) des vecteurs de caractères, leurs éléments sont envoyés, chacun sur une ligne séparée, à gnuplot sous forme de commandes. Par exemple, plot("set term X11") fait que gnuplot génère une sortie X11. Même les commandes demandant des informations à gnuplot, comme plot("show term") sont acceptables (bien que vous puissiez temporairement perdre de vue le prompt d'Algae). N'utilisez pas les commandes "exit" ou "quit" de gnuplot, elles provoquent la fermeture de gnuplot sans qu'Algae ne le sache.

Si plusieurs paramètres sont donnés à plot et que le dernier est un scalaire entier, il est alors considéré comme un identifiant pour le processus de plot. Cela vous permet d'avoir plusieurs plots ouverts à la fois. Si aucun identifiant n'est donné, le plot actif est alors supprimé et remplacé par un nouveau avec le même identifiant. Le plot "actif" est celui référencé en dernier, ou 1 s'il n'y a pas de plot ouvert. La fonction replot peut être utilisée pour modifier un plot ouvert.

Tous les autres arguments donnés à plot sont considérés comme des données à tracer. Les vecteurs sont tracés en utilisant leurs valeurs d'élément comme ordonnées et leurs étiquettes pour les abscisses. Les matrices à 2 colonnes sont tracées en utilisant la deuxième colonne pour les ordonnées et la première colonne pour les abscisses. Une matrice à 3 colonnes est tracée sous forme de courbe en trois dimensions, la troisième colonne spécifiant les ordonnées. Les tracés de surface sont obtenus à l'aide de la fonction splot.

Si les données fournies à plot sont un vecteur, mais n'ont pas d'étiquettes, alors les indices des éléments sont utilisés à la place des étiquettes.

Plusieurs courbes peuvent être affichées sur le même tracé, soit en donnant à plot deux paramètres de données, soit (mieux encore) en fournissant les données dans un tableau. Lorsque les données sont fournies dans un tableau (même s'il ne contient qu'un seul membre), le nom du membre est utilisé dans la légende du tracé. Sinon, plot utilise les noms "y_1" et "y_2".

Si les données sont fournies dans un tableau, tous les membres qui sont eux-mêmes des tableaux sont fournis à gnuplot dans un seul fichier de données. Cela signifie que le même type de ligne et de point est utilisé. Par exemple, si x et y sont des vecteurs à tracer, plot({x;y}) trace les deux, chacun avec un type de ligne et de point différent et décrit par un nom dans la légende. D'autre part, plot({z={x;y}}) les trace avec le même type de ligne et de point et nomme la combinaison "z" dans la légende.

Si plot est appelé sans paramètre, il renvoie un vecteur des identifiants de plots ouverts. Ce vecteur est trié du plus récent au moins récent, de sorte que le plot «actif» est le premier.

Voici un exemple simulant le système Van der Pol et trace les résultats :

  1. xdot = function( t; x ) {
  2.     return x[1]*(1-x[2]^2)-x[2], x[1];
  3. }
  4. x = ode4( xdot; 0; 20; 0,.25 );
  5. plot( "Définir les lignes de style de données"; { x1=x[1;]; x2=x[2;] } );

Voir également division, intrigue et intrigue secondaire.

Fonction :

replot ( ... )

La fonction replot permet de modifier ou de réafficher les tracés créés avec les fonctions plot ou splot. Elle prend au maximum 2 paramètres. Si le premier paramètre est de type caractère, il est passé à gnuplot sous forme de commandes.

Le dernier paramètre est l'identifiant de tracé facultatif. S'il n'est pas fourni, le tracé actif est utilisé par défaut.

Voir aussi plot, splot et unplot.

Fonction :

splot ( ... )

La fonction splot permet de tracer des surfaces en trois dimensions. À l'exception de la forme des données, son entrée est identique à celle de la fonction plot. Les données sont spécifiées sous forme de matrice d'ordonnées. Les étiquettes de la matrice, ou les indices correspondants si les étiquettes n'existent pas, sont utilisés pour les abscisses.

Voir aussi plot, replot et unplot.

Fonction :

umin ( objective; start; options )

La fonction umin effectue une minimisation sans contrainte à l'aide de la méthode de recherche directe Nelder-Mead. Elle ne possède pas les fonctionnalités ou la sophistication de npsol, mais elle fonctionne bien dans certains cas, en particulier lorsque la surface objective n'est pas lisse.

Le paramètre objective est une fonction prenant un ou deux paramètres et renvoie la valeur de l'objectif à ce point. Le premier paramètre est un vecteur de variables de conception. Le deuxième paramètre, étant facultatif, est transmis sans changement du membre params de le paramètre options à umin lui-même.

Le paramètre start est un vecteur entier ou réel spécifiant le point de départ.

Le paramètre d'options peut être NULL ou un tableau contenant la convergence et d'autres spécifications. Les options significatives sont :

Option Description
bound La valeur minimale autorisée pour la fonction objective. La valeur par défaut est -1e32.
display Une fonction appelée à chaque itération « réussie » avec le point de conception actuel comme seul paramètre. Cela peut être utilisé, par exemple, pour tracer la conception au fur et à mesure de ses modifications.
evals Nombre maximal d'évaluations de fonctions objectives autorisées. La valeur par défaut est 1 000.
iter Nombre maximal d'itérations autorisées. La valeur par défaut est 100.
params La valeur de ce membre est passée comme deuxième paramètre à la fonction objective.
right Si ce membre existe, alors le simplexe initial a des angles droits. Par défaut, le simplexe initial a des côtés de longueur égale.
size La taille initiale du simplexe. Par défaut, il s'agit de la valeur la plus élevée entre 1 et la norme infinie du vecteur de départ.
tol La taille relative du simplexe, en dessous de laquelle l'itération est considérée comme ayant convergé. La tolérance est de 1e-6 par défaut.
verbose Si ce membre existe, alors les informations sont affichées à chaque itération «réussie».

La valeur de retour de umin est une table avec les membres suivants :

Membre Description
evals Le nombre d'évaluations de fonctions objectives.
inform Un code de retour spécifiant la réussite ou l'échec :
Valeur Description
0 Succès
1 échec, objectif atteint
2 échec, limite d'évaluation de fonction dépassée
3 échec, limite d'itération dépassée
iter Le nombre d'itérations effectuées.
msg Un message correspondant au code d'information.
obj La valeur objective finale.
sol Le point de conception final.

Ce code est basé sur nmsmax, une fonction MATLAB de Nick Higham.

Voir aussi npsol.

Fonction :

unplot ( id )

La fonction unplot est utilisée pour terminer les tracés créés avec les fonctions plot ou splot. Le paramètre id, scalaire ou vecteur entier, spécifie les identifiants des tracés à terminer. Si aucun id n'est fourni, le tracé actif est terminé. Vous pouvez terminer tous les tracés ouverts avec unplot(plot()).

Voir aussi plot, replot et splot.

Divers

Fonction :

all ( x )

La fonction all évalue la «vérité» de son paramètre x de la même manière que la fonction test, à ceci près que les vecteurs et les matrices ne sont «vrais» que si tous leurs éléments sont «vrais». Par exemple, all(1,0) renvoie 0 tandis que test(1,0) renvoie 1. Si x n'a aucun élément, all renvoie 0.

Voir également test et equal.

Fonction :

atof ( s )

La fonction atof convertit les chaînes de caractères en nombres réels. L'argument s peut être un scalaire, un vecteur ou une matrice. L a fonction lit uniquement jusqu'au premier caractère non reconnu de chaque chaîne et ignore tout ce qui reste. Si le premier caractère d'une chaîne de caractères n'est pas reconnu, la valeur est alors considérée comme nulle.

Fonction :

char ( v )

La fonction char convertit le vecteur v en une chaîne de caractères ; chaque élément de v contribue à un seul caractère en fonction de sa valeur ASCII. Par exemple, char(65,66,67) renvoie la chaîne de caractères «ABC».

Si un élément de v est inférieur à 0 ou supérieur à 255, il «s'enroule» (modulo 256). Ainsi, char(65) et char(65+256) renvoient tous deux la chaîne de caractères «A».

Les chaînes de caractères d'Algae se terminent par un caractère NUL (0). Pour la fonction char, cela signifie que si un élément de v est nul (ou un multiple de 256), la chaîne se termine à ce point. Par exemple, char(65,0,66) renvoie la chaîne «A».

Fonction :

class ( x )

La fonction de classe renvoie une chaîne de caractères (telle que «scalar» ou «table») décrivant la classe de x.

Fonction :

equal ( a; b )

Cette fonction teste l'égalité entre a et b. Pour les vecteurs et les matrices, elle renvoie true (1) uniquement si chaque paire d'éléments correspondants est égale, et false (0) dans le cas contraire. Pour toutes les autres classes, cette fonction renvoie la même valeur que l'expression a==b.

Voir aussi test.

Fonction :

members ( e )

Cette fonction renvoie un vecteur contenant les noms des membres de e.

Fonction :

info ( topic )

Cette fonction lance un navigateur interactif pour la documentation d'Algae. Le paramètre optionnel topic (un caractère scalaire) vous amène directement à ce topic. Par exemple, info("sort") vous amène directement à la description de la fonction sort.

Si possible, info utilise un navigateur HTML basé sur X (comme netscape ou mosaic). Sinon, un navigateur HTML basé sur des caractères (comme lynx) sera essayé. En dernier recours, le navigateur GNU Info est appelé.

Les noms des navigateurs disponibles sont attribués par le code de démarrage en tant que membres xhtml, html et info de la table globale $programs. Pour empêcher Algae d'utiliser un navigateur particulier, définissez simplement le membre approprié de $programs sur une chaîne de caractères de longueur zéro. Si vous préférez utiliser Info, par exemple, vous pouvez simplement mettre la ligne :

  1. $programs.xhtml = $programs.html = "";

dans votre fichier «.algae».

Fonction :

prof ( infile; outfile; threshold )

La fonction prof lit un fichier «algae.out» produit par le profileur d'exécution d'Algae (l'option «-p») et le résume par fichier et par numéro de ligne. Le paramètre infile spécifie le nom du fichier. outfile spécifie le fichier de sortie ; s'il est NULL, stdout est utilisé.

Le paramètre threshold peut être utilisé pour tronquer les listes de résumé. La troncature se produit après que suffisamment d'entrées ont été affichées pour représenter le pourcentage de seuil du nombre total de résultats. Si threshold est NULL, aucune troncature n'est effectuée.

Vous trouverez ci-dessous un exemple de sortie prof, obtenue avec la commande prof("algae.out";;50);.

Algae execution profile listing.

628 total hits

--- by file ---

          hits   % hits    cum %   file
           201    32.01    32.01   lqrtest.A
           127    20.22    52.23   /usr/local/lib/algae/ode.A

--- by line ---

          hits   % hits    cum %   line   file
           130    20.70    20.70     88   lqrtest.A
                42     6.69    27.39      1   /usr/local/lib/algae/plot.A
                40     6.37    33.76     38   lqrtest.A
                21     3.34    37.10      1   /usr/local/lib/algae/ode.A
                17     2.71    39.81     44   /usr/local/lib/algae/ode.A
                15     2.39    42.20     42   /usr/local/lib/algae/ode.A
                15     2.39    44.59     41   /usr/local/lib/algae/ode.A
                14     2.23    46.82      1   /usr/local/lib/algae/ode4.A
                12     1.91    48.73      1   /usr/local/lib/algae/spline.A
                10     1.59    50.32      1   lqrtest.A

Tout d'abord, notez que le nombre de hits comptés dans cet exemple n'était que de 628. Une précision à quatre chiffres dans les statistiques est clairement injustifiée avec un échantillon aussi petit. La première colonne indique le nombre de hits du profileur comptés pour chaque fichier ou numéro de ligne particulier. La deuxième colonne réitère ce chiffre en pourcentage du nombre total de hits. La troisième colonne donne le pourcentage cumulé.

Tous les hits du profileur se produisant pendant qu'Algae analyse un fichier sont comptés pour sa première ligne. Cela est normalement insignifiant par rapport à l'exécution, mais cela explique pourquoi la ligne 1 apparaît si souvent dans le rapport « par ligne » dans l'exemple ci-dessus.

Aucun fichier n'est fermé dans prof. Normalement, cela signifie que vous devez les fermer vous-même si prof doit être appelé plus d'une fois.

Fonction :

show ( e )

Cette fonction affiche des informations sur l'entité e et ses membres.

Fonction :

split ( s; w )

La fonction split prend un paramètre scalaire de type caractère, le divise en jetons et renvoie les jetons dans un vecteur de caractères. Chaque jeton est délimité par un ou plusieurs caractères de w. Par exemple, split("/bin:/usr/bin";":") renvoie le vecteur :

(  "/bin"    , "/usr/bin" )

Si w est NULL, la chaîne de caractères " \t\n" est utilisée. Ainsi split("Ceci est un test.") renvoie le vecteur :

( "Ceci" , "est" , "un" , "test." )

Fonction :

string ( e )

La fonction string convertit son paramètre e en type caractère. Si e est NULL, un scalaire de caractère de longueur nulle est renvoyé. Par exemple, string(1/(1:3)) renvoie le vecteur :

(  "1"       , "0.5"     , "0.333333" )

Actuellement, le format de sortie ne peut pas être modifié.

Fonction :

substr ( c; start; length )

La fonction substr renvoie la sous-chaîne de la chaîne de caractères c, commençant à l'index start, de longueur length. L'entier start doit être supérieur à zéro ; s'il dépasse la longueur de c, une chaîne de caractères longueur nulle est renvoyée. Si length est NULL, tous les caractères restants de c sont renvoyés ; sinon, length ne doit pas être négatif.

Voir aussi dice, split et string.

Fonction :

test ( e )

La fonction de test évalue la «vérité» de e de la même manière que l'instruction if d'Algae le ferait, en renvoyant 1 pour vrai et 0 pour faux. Les entités suivantes sont fausses :

Toutes les autres sont vraies. Notez que si e est un tableau (scalaire, vecteur ou matrice), alors test renvoie true si un élément de e est différent de zéro (ou a une longueur différente de zéro, pour le type caractère).

Un exemple d'utilisation de test est la fonction equal d'Algae, s'écrivant comme suit :

  1. equal = function( a; b ) { return !test( a != b ); }

Si a et b sont tous deux des matrices, alors a!=b renvoie une matrice qui est entièrement composée de zéros uniquement si chaque paire d'éléments est égale. Dans ce cas, test renvoie 0 et ! le remplace par 1.

Voir aussi equal et all.

Fonction :

time ( )

La fonction time renvoie le nombre de secondes de temps utilisateur utilisées par le processus actuel. Sur la plupart des machines, sa précision n'est pas supérieure à 1/10 de seconde.

Fonction :

tolower ( s )

La fonction tolower convertit les chaînes en minuscules. Chaque lettre est convertie en fonction des paramètres régionaux actuels. Le paramètre S peut être un caractère scalaire, un vecteur ou une matrice.

Voir aussi toupper.

Fonction :

toupper ( s )

La fonction toupper convertit les chaînes en majuscules. Chaque lettre est convertie en fonction des paramètres régionaux actuels. Le paramètre S peut être un caractère scalaire, un vecteur ou une matrice.

Voir aussi tolower.

Fonction :

what ( )

La fonction what renvoie une table contenant toutes les fonctions globales. Voir aussi who.

Fonction :

who ( opt )

La fonction who renvoie une table contenant toutes les variables globales n'étant ni des fonctions ni NULL. Les variables dont le nom commence par «$» sont exclues, sauf si le paramètre optionnel opt est égal à «$ . Voir aussi what.



Dernière mise à jour : Dimanche, le 15 décembre 2024