15.3. Algorithme de tâche « MeasurementsOptimalPositioningTask »

Cet algorithme est réservé à une utilisation en interface textuelle (TUI), et donc pas en interface graphique (GUI).

15.3.1. Description

Cet algorithme permet d’établir la position optimale de mesures d’un champ physique \mathbf{y}, pour en assurer l’interpolation la meilleure possible. Ces positions optimales de mesure sont déterminées de manière itérative, à partir d’un ensemble de vecteurs d’état \mathbf{y} pré-existants (usuellement appelés « snapshots » en méthodologie de bases réduites) ou obtenus par une simulation de ce(s) champ(s) physiqu(e) d’intérêt au cours de l’algorithme. Chacun de ces vecteurs d’état est habituellement (mais pas obligatoirement) le résultat \mathbf{y} d’une simulation à l’aide de l’opérateur H restituant le (ou les) champ(s) complet(s) pour un jeu de paramètres donné \mathbf{x}, ou d’une observation explicite du (ou des) champ(s) complet(s) \mathbf{y}.

Pour établir la position optimale de mesures, on utilise une méthode de type Empirical Interpolation Method (EIM [Barrault04]) ou Discrete Empirical Interpolation Method (DEIM [Chaturantabut10]), qui établit un modèle réduit de type Reduced Order Model (ROM), avec contraintes (variante « lcEIM » ou « lcDEIM ») ou sans contraintes (variante « EIM » ou « DEIM ») de positionnement. Pour la performance, il est recommandé d’utiliser la variante « lcEIM » ou « EIM » lorsque la dimension de l’espace des champs complets est grande.

Il y a deux manières d’utiliser cet algorithme:

  1. Dans son usage le plus simple, si l’ensemble des vecteurs d’état physique \mathbf{y} est pré-existant, il suffit de le fournir sous la forme d’une collection ordonnée par l’option « EnsembleOfSnapshots » de l’algorithme. C’est par exemple ce que l’on obtient par défaut si l’ensemble des états a été généré par un Algorithme de tâche « EnsembleOfSimulationGenerationTask ».

  2. Si l’ensemble des vecteurs d’état physique \mathbf{y} doit être obtenu par des simulations explicites au cours de l’algorithme, alors on doit fournir à la fois l’opérateur de simulation du champ complet, ici identifié à l’opérateur d’observation H du champ complet, et le plan d’expérience de l’espace des états \mathbf{x} paramétriques.

Dans le cas où l’on fournit le plan d’expérience, l’échantillonnage des états \mathbf{x} peut être fourni comme pour un Algorithme de tâche « EnsembleOfSimulationGenerationTask », explicitement ou sous la forme d’hypercubes, explicites ou échantillonnés selon des distributions courantes, ou à l’aide d’un échantillonnage par hypercube latin (LHS) ou par séquence de Sobol. Les calculs sont optimisés selon les ressources informatiques disponibles et les options demandées par l’utilisateur. On pourra se reporter aux Conditions requises pour décrire un échantillonnage d’états pour une illustration de l’échantillonnage. Attention à la taille de l’hypercube (et donc au nombre de calculs) qu’il est possible d’atteindre, elle peut rapidement devenir importante.

_images/mop_determination.png

Schéma général d’utilisation de l’algorithme

Il est possible d’exclure a priori des positions potentielles pour le positionnement des mesures, en utilisant le variant « lcEIM » ou « lcDEIM » d’analyse pour une recherche de positionnement contraint.

15.3.2. Commandes requises et optionnelles

Les commandes générales requises, disponibles en édition dans l’interface graphique ou textuelle, sont les suivantes :

Aucune

Les commandes optionnelles générales, disponibles en édition dans l’interface graphique ou textuelle, sont indiquées dans la Liste des commandes et mots-clés pour un cas orienté tâche ou étude dédiée. De plus, les paramètres de la commande « AlgorithmParameters » permettent d’indiquer les options particulières, décrites ci-après, de l’algorithme. On se reportera à la Description des options d’un algorithme par « AlgorithmParameters » pour le bon usage de cette commande.

Les options sont les suivantes :

EnsembleOfSnapshots

Liste de vecteurs ou matrice. Cette clé contient une collection ordonnée de vecteurs d’état physique \mathbf{y} (nommés « snapshots » en terminologie de bases réduites), avec un état complet par colonne si c’est une matrice, ou un état complet par élément si c’est une liste. Important : la numérotation du support ou des points, sur lequel ou auxquels sont fournis une valeur d’état dans chaque vecteur, est implicitement celle de l’ordre naturel de numérotation du vecteur d’état, de 0 à la « taille moins 1 » de ce vecteur.

Exemple : {"EnsembleOfSnapshots":[y1, y2, y3...]}

ExcludeLocations

Liste d’entiers ou de noms. Cette clé indique la liste des points du vecteur d’état exclus de la recherche optimale. La valeur par défaut est une liste vide. La liste peut contenir soit des indices de points (dans l’ordre interne implicite d’un vecteur d’état), soit des noms des points (qui doivent exister dans la liste des noms de positions indiquées par le mot-clé « NameOfLocations » pour pouvoir être exclus). Par défaut, si les éléments de la liste sont des chaînes de caractères assimilables à des indices, alors ces chaînes sont bien considérées comme des indices et pas des noms.

Rappel important : la numérotation de ces points exclus doit être identique à celle qui est adoptée, implicitement et impérativement, par les variables constituant un état considéré arbitrairement sous forme unidimensionnelle.

Exemple : {"ExcludeLocations":[3, 125, 286]} ou {"ExcludeLocations":["Point3", "XgTaC"]}

ErrorNorm

Nom prédéfini. Cette clé indique la norme utilisée pour le résidu qui contrôle la recherche optimale. Le défaut est la norme « L2 ». Les critères possibles sont dans la liste suivante : [« L2 », « Linf »].

Exemple : {"ErrorNorm":"L2"}

ErrorNormTolerance

Valeur réelle. Cette clé indique la valeur à partir laquelle le résidu associé à l’approximation est acceptable, ce qui conduit à arrêter la recherche optimale. La valeur par défaut est de 1.e-7 (ce qui équivaut usuellement à une quasi-absence de critère d’arrêt car l’approximation est moins précise), et il est recommandé de l’adapter aux besoins pour des problèmes réels. Une valeur habituelle, recommandée pour arrêter la recherche sur critère de résidu, est de 1.e-2.

Exemple : {"ErrorNormTolerance":1.e-7}

MaximumNumberOfLocations

Valeur entière. Cette clé indique le nombre maximum possible de positions trouvée dans la recherche optimale. La valeur par défaut est 1. La recherche optimale peut éventuellement trouver moins de positions que ce qui est requis par cette clé, comme par exemple dans le cas où le résidu associé à l’approximation est inférieur au critère et conduit à l’arrêt anticipé de la recherche optimale.

Exemple : {"MaximumNumberOfLocations":5}

NameOfLocations

Liste de noms. Cette clé indique une liste explicite de noms des variables ou de positions, positionnées comme dans un vecteur d’état considéré arbitrairement sous forme unidimensionnelle. La valeur par défaut est une liste vide. Pour être utilisée, cette liste doit avoir la même longueur que celle d’un état physique.

Rappel important : l’ordre des noms est, implicitement et impérativement, le même que celui des variables constituant un état considéré arbitrairement sous forme unidimensionnelle.

Exemple : {"NameOfLocations":["Point3", "Location42", "Position125", "XgTaC"]}

SampleAsExplicitHyperCube

Liste de liste de valeurs réelles. Cette clé décrit les points de calcul sous la forme d’un hyper-cube, dont on donne la liste des échantillonnages explicites de chaque variable comme une liste. C’est donc une liste de listes, chacune étant de taille potentiellement différente. Par nature, les points sont inclus dans le domaine défini par les bornes des listes explicites de chaque variable.

Exemple : {"SampleAsExplicitHyperCube":[[0.,0.25,0.5,0.75,1.], [-2,2,1]]} pour un espace d’état de dimension 2.

SampleAsIndependantRandomVariables

Liste de triplets [Nom, Paramètres, Nombre]. Cette clé décrit les points de calcul sous la forme d’un hyper-cube, dont les points sur chaque axe proviennent de l’échantillonnage aléatoire indépendant de la variable d’axe, selon la spécification de la distribution, de ses paramètres et du nombre de points de l’échantillon, sous la forme d’une liste ['distribution', [parametres], nombre] pour chaque axe. Les distributions possibles sont “normal” de paramètres (mean,std), “lognormal” de paramètres (mean,sigma), “uniform” de paramètres (low,high), ou “weibull” de paramètre (shape). C’est donc une liste de la même taille que celle de l’état. Par nature, les points sont inclus le domaine non borné ou borné selon les caractéristiques des distributions choisies par variable.

Exemple : {"SampleAsIndependantRandomVariables":[['normal',[0.,1.],3], ['uniform',[-2,2],4]]} pour un espace d’état de dimension 2.

SampleAsMinMaxLatinHyperCube

Liste de triplets de paires réelles. Cette clé décrit le domaine borné dans lequel les points de calcul seront placés, sous la forme d’une paire [min,max] pour chaque composante de l’état. Les bornes inférieures sont incluses. Cette liste de paires, en nombre identique à la taille de l’espace des états, est complétée par une paire d’entier [dim,nbr] comportant la dimension de l’espace des états et le nombre souhaité de points d’échantillonnage. L’échantillonnage est ensuite construit automatiquement selon la méthode de l’hypercube Latin (LHS). Par nature, les points sont inclus dans le domaine défini par les bornes explicites.

Exemple : {"SampleAsMinMaxLatinHyperCube":[[0.,1.],[-1,3]]+[[2,11]]} pour un espace d’état de dimension 2 et 11 points d’échantillonnage.

SampleAsMinMaxSobolSequence

Liste de triplets de paires réelles. Cette clé décrit le domaine borné dans lequel les points de calcul seront placés, sous la forme d’une paire [min,max] pour chaque composante de l’état. Les bornes inférieures sont incluses. Cette liste de paires, en nombre identique à la taille de l’espace des états, est complétée par une paire d’entier [dim,nbr] comportant la dimension de l’espace des états et le nombre minimum souhaité de points d’échantillonnage (par construction, le nombre de points générés dans la séquence de Sobol sera la puissance de 2 immédiatement supérieure à ce nombre minimum). L’échantillonnage est ensuite construit automatiquement selon la méthode de séquences de Sobol. Par nature, les points sont inclus dans le domaine défini par les bornes explicites.

Remarque : il est nécessaire de disposer de Scipy en version supérieure à 1.7.0 pour utiliser cette option échantillonnage.

Exemple : {"SampleAsMinMaxSobolSequence":[[0.,1.],[-1,3]]+[[2,11]]} pour un espace d’état de dimension 2 et au moins 11 points d’échantillonnage (il y aura 16 points en pratique).

SampleAsMinMaxStepHyperCube

Liste de triplets de valeurs réelles. Cette clé décrit les points de calcul sous la forme d’un hyper-cube, dont on donne la liste des échantillonnages implicites de chaque variable par un triplet [min,max,step]. C’est donc une liste de la même taille que celle de l’état. Les bornes sont incluses. Par nature, les points sont inclus dans le domaine défini par les bornes explicites.

Exemple : {"SampleAsMinMaxStepHyperCube":[[0.,1.,0.25],[-1,3,1]]} pour un espace d’état de dimension 2.

SampleAsnUplet

Liste d’états. Cette clé décrit les points de calcul sous la forme d’une liste de n-uplets, chaque n-uplet étant un état. Par nature, les points sont inclus dans le domaine borné défini comme l’enveloppe convexe des points explicitement désignés.

Exemple : {"SampleAsnUplet":[[0,1,2,3],[4,3,2,1],[-2,3,-4,5]]} pour 3 points dans un espace d’état de dimension 4.

SetDebug

Valeur booléenne. La variable conduit à l’activation, ou pas, du mode de débogage durant l’évaluation de la fonction ou de l’opérateur. La valeur par défaut est « True », les choix sont « True » ou « False ».

Exemple : {"SetDebug":False}

SetSeed

Valeur entière. Cette clé permet de donner un nombre entier pour fixer la graine du générateur aléatoire utilisé dans l’algorithme. Par défaut, la graine est laissée non initialisée, et elle utilise ainsi l’initialisation par défaut de l’ordinateur, qui varie donc à chaque étude. Pour assurer la reproductibilité de résultats impliquant des tirages aléatoires, il est fortement conseillé d’initialiser la graine. Une valeur simple est par exemple 123456789. Il est conseillé de mettre un entier à plus de 6 ou 7 chiffres pour bien initialiser le générateur aléatoire.

Exemple : {"SetSeed":123456789}

StoreSupplementaryCalculations

Liste de noms. Cette liste indique les noms des variables supplémentaires, qui peuvent être disponibles au cours du déroulement ou à la fin de l’algorithme, si elles sont initialement demandées par l’utilisateur. Leur disponibilité implique, potentiellement, des calculs ou du stockage coûteux. La valeur par défaut est donc une liste vide, aucune de ces variables n’étant calculée et stockée par défaut (sauf les variables inconditionnelles). Les noms possibles pour les variables supplémentaires sont dans la liste suivante (la description détaillée de chaque variable nommée est donnée dans la suite de cette documentation par algorithme spécifique, dans la sous-partie « Informations et variables disponibles à la fin de l’algorithme ») : [ « EnsembleOfSimulations », « EnsembleOfStates », « ExcludedPoints », « OptimalPoints », « ReducedBasis », « Residus », « SingularValues », ].

Exemple : {"StoreSupplementaryCalculations":["CurrentState", "Residu"]}

Variant

Nom prédéfini. Cette clé permet de choisir l’une des variantes possibles pour la recherche du positionnement optimal. La variante par défaut est la version contrainte par des positions exclues « lcEIM » ou « PositioningBylcEIM », et les choix possibles sont « EIM » ou « PositioningByEIM » (utilisant l’algorithme EIM original), « lcEIM » ou « PositioningBylcEIM » (utilisant l’algorithme EIM contraint par des positions exclues, nommé « Location Constrained EIM »), « DEIM » ou « PositioningByDEIM » (utilisant l’algorithme DEIM original), « lcDEIM » ou « PositioningBylcDEIM » (utilisant l’algorithme DEIM contraint par des positions exclues, nommé « Location Constrained DEIM »). Il est fortement recommandé de conserver la valeur par défaut.

Exemple : {"Variant":"lcEIM"}

15.3.3. Informations et variables disponibles à la fin de l’algorithme

En sortie, après exécution de l’algorithme, on dispose d’informations et de variables issues du calcul. La description des Variables et informations disponibles en sortie indique la manière de les obtenir par la méthode nommée get, de la variable « ADD » du post-processing en interface graphique, ou du cas en interface textuelle. Les variables d’entrée, mises à disposition de l’utilisateur en sortie pour faciliter l’écriture des procédures de post-processing, sont décrites dans l”Inventaire des informations potentiellement disponibles en sortie.

Sorties permanentes (non conditionnelles)

Les sorties non conditionnelles de l’algorithme sont les suivantes :

OptimalPoints

Liste de série d’entiers. Chaque élément est une série, contenant les indices des positions idéales ou points optimaux auxquels une mesure est requise, déterminés par la recherche optimale, rangés par ordre de préférence décroissante et dans le même ordre que les vecteurs de base réduite trouvés itérativement.

Exemple : op = ADD.get("OptimalPoints")[-1]

Ensemble des sorties à la demande (conditionnelles ou non)

L’ensemble des sorties (conditionnelles ou non) de l’algorithme, classées par ordre alphabétique, est le suivant :

EnsembleOfSimulations

Liste de vecteurs ou matrice. Chaque élément est une collection ordonnée de vecteurs d’état physique ou d’état simulé \mathbf{y} (nommés « snapshots » en terminologie de bases réduites), avec 1 état par colonne si c’est une matrice, ou 1 état par élément si c’est une liste. Important : la numérotation du support ou des points, sur lequel ou auxquels sont fournis une valeur d’état dans chaque vecteur, est implicitement celle de l’ordre naturel de numérotation du vecteur d’état, de 0 à la « taille moins 1 » de ce vecteur.

Exemple : {"EnsembleOfSimulations":[y1, y2, y3...]}

EnsembleOfStates

Liste de vecteurs ou matrice. Chaque élément est une collection ordonnée de vecteurs d’état physique ou d’état paramétrique \mathbf{x}, avec 1 état par colonne si c’est une matrice, ou 1 état par élément si c’est une liste. Important : la numérotation du support ou des points, sur lequel ou auxquels sont fournis une valeur d’état dans chaque vecteur, est implicitement celle de l’ordre naturel de numérotation du vecteur d’état, de 0 à la « taille moins 1 » de ce vecteur.

Exemple : {"EnsembleOfStates":[x1, x2, x3...]}

ExcludedPoints

Liste de série d’entiers. Chaque élément est une série, contenant les indices des points exclus de la recherche optimale, selon l’ordre des variables d’un vecteur d’état considéré arbitrairement sous forme unidimensionnelle.

Exemple : ep = ADD.get("ExcludedPoints")[-1]

OptimalPoints

Liste de série d’entiers. Chaque élément est une série, contenant les indices des positions idéales ou points optimaux auxquels une mesure est requise, déterminés par la recherche optimale, rangés par ordre de préférence décroissante et dans le même ordre que les vecteurs de base réduite trouvés itérativement.

Exemple : op = ADD.get("OptimalPoints")[-1]

ReducedBasis

Liste de matrices. Chaque élément est une matrice, contenant dans chaque colonne un vecteur de la base réduite obtenue par la recherche optimale, rangés par ordre de préférence décroissante, et dans le même ordre que les points idéaux trouvés itérativement.

Lorsque c’est une donnée d’entrée, elle est identique à une sortie unique d’un Algorithme de tâche « MeasurementsOptimalPositioningTask ».

Exemple : rb = ADD.get("ReducedBasis")[-1]

Residus

Liste de série de valeurs réelles. Chaque élément est une série, contenant les valeurs du résidu particulier vérifié lors du déroulement de l’algorithme.

Exemple : rs = ADD.get("Residus")[-1]

SingularValues

Liste de série de valeurs réelles. Chaque élément est une série, contenant les valeurs singulières obtenues par une décomposition SVD d’un ensemble de vecteurs d’états complets. Le nombre de valeurs singulières retenues n’est pas limité par la taille de la base réduite demandée.

Exemple : sv = ADD.get("SingularValues")[-1]

15.3.4. Exemples d’utilisation en Python (TUI)

Voici un ou des exemples très simple d’usage de l’algorithme proposé et de ses paramètres, écrit en [DocR] Interface textuelle pour l’utilisateur (TUI/API). De plus, lorsque c’est possible, les informations indiquées en entrée permettent aussi de définir un cas équivalent en interface graphique [DocR] Interface graphique pour l’utilisateur (GUI/EFICAS).

15.3.4.1. Premier exemple

Cet exemple décrit la mise en oeuvre d’une recherche de positionnement optimal de mesures. Pour l’illustration, on construit une collection artificielle de champs physiques très simple (engendré ici de manière à exister dans un espace vectoriel de dimension 2). La recherche ADAO par défaut permet ensuite d’obtenir aisément 2 positions optimales pour les mesures, comme illustré par l’affichage en fin de script.

# -*- coding: utf-8 -*-
#
from numpy import array, arange
#
dimension = 7
#
print("Définition d'un ensemble artificiel de champs physiques")
print("-------------------------------------------------------")
Ensemble = array( [i+arange(dimension) for i in range(7)] ).T
print("- Dimension de l'espace des champs physiques...........: %i"%dimension)
print("- Nombre de vecteurs de champs physiques...............: %i"%Ensemble.shape[1])
print("- Collection des champs physiques (un par colonne)")
print(Ensemble)
print()
#
print("Recherche des positions optimales de mesure")
print("-------------------------------------------")
from adao import adaoBuilder
case = adaoBuilder.New()
case.setAlgorithmParameters(
    Algorithm = 'MeasurementsOptimalPositioningTask',
    Parameters = {
        "EnsembleOfSnapshots":Ensemble,
        "MaximumNumberOfLocations":3,
        "ErrorNorm":"L2",
    }
)
case.execute()
print("- Calcul ADAO effectué")
print()
#
print("Affichage des positions optimales de mesure")
print("-------------------------------------------")
op = case.get("OptimalPoints")[-1]
print("- Nombre de positions optimales de mesure..............: %i"%op.size)
print("- Positions optimales de mesure, numérotées par défaut.: %s"%op)
print()

Le résultat de son exécution est le suivant :

Définition d'un ensemble artificiel de champs physiques
-------------------------------------------------------
- Dimension de l'espace des champs physiques...........: 7
- Nombre de vecteurs de champs physiques...............: 7
- Collection des champs physiques (un par colonne)
[[ 0  1  2  3  4  5  6]
 [ 1  2  3  4  5  6  7]
 [ 2  3  4  5  6  7  8]
 [ 3  4  5  6  7  8  9]
 [ 4  5  6  7  8  9 10]
 [ 5  6  7  8  9 10 11]
 [ 6  7  8  9 10 11 12]]

Recherche des positions optimales de mesure
-------------------------------------------
- Calcul ADAO effectué

Affichage des positions optimales de mesure
-------------------------------------------
- Nombre de positions optimales de mesure..............: 2
- Positions optimales de mesure, numérotées par défaut.: [6 0]

15.3.4.2. Second exemple

Cet exemple décrit le même positionnement optimal de mesures, suivi d’une analyse de la représentation réduite et des erreurs obtenues lors de la recherche des positions optimales.

La partie initiale du script est identique au précédent, avec la même collection artificielle de champs physiques et la même analyse par ADAO. On ajoute ensuite la récupération de la base réduite et un exemple très simple de décomposition sur la base réduite, exacte dans ce cas simple, de l’un des champs physiques initialement fournis.

# -*- coding: utf-8 -*-
#
from numpy import array, arange
#
dimension = 7
#
print("Définition d'un ensemble artificiel de champs physiques")
print("-------------------------------------------------------")
Ensemble = array( [i+arange(dimension) for i in range(7)] ).T
print("- Dimension de l'espace des champs physiques...........: %i"%dimension)
print("- Nombre de vecteurs de champs physiques...............: %i"%Ensemble.shape[1])
print("- Collection des champs physiques (un par colonne)")
print(Ensemble)
print()
#
print("Recherche des positions optimales de mesure")
print("-------------------------------------------")
from adao import adaoBuilder
case = adaoBuilder.New()
case.setAlgorithmParameters(
    Algorithm = 'MeasurementsOptimalPositioningTask',
    Parameters = {
        "EnsembleOfSnapshots":Ensemble,
        "MaximumNumberOfLocations":3,
        "ErrorNorm":"L2",
        "StoreSupplementaryCalculations":[
            "ReducedBasis",
            "Residus",
        ],
    }
)
case.execute()
print("- Calcul ADAO effectué")
print()
#
print("Affichage des positions optimales de mesure")
print("-------------------------------------------")
op = case.get("OptimalPoints")[-1]
print("- Nombre de positions optimales de mesure..............: %i"%op.size)
print("- Positions optimales de mesure, numérotées par défaut.: %s"%op)
print()
#
print("Représentation réduite et informations d'erreurs")
print("------------------------------------------------")
rb = case.get("ReducedBasis")[-1]
print("- Nombre de vecteurs de la base réduite................: %i"%rb.shape[1])
print("- Vecteurs de la base réduite (un par colonne)\n")
print(rb)
rs = case.get("Residus")[-1]
print("- Résidus ordonnés d'erreur de reconstruction\n ",rs)
print()
a0, a1 = 7, -2.5
print("- Exemple élémentaire de reconstruction du second champ comme une")
print("  combinaison linéaire des deux vecteurs de base, qui peuvent être")
print("  multipliés par les coefficients respectifs %.1f et %.1f :"%(a0,a1))
print( a0*rb[:,0] + a1*rb[:,1])
print()

Le résultat de son exécution est le suivant :

Définition d'un ensemble artificiel de champs physiques
-------------------------------------------------------
- Dimension de l'espace des champs physiques...........: 7
- Nombre de vecteurs de champs physiques...............: 7
- Collection des champs physiques (un par colonne)
[[ 0  1  2  3  4  5  6]
 [ 1  2  3  4  5  6  7]
 [ 2  3  4  5  6  7  8]
 [ 3  4  5  6  7  8  9]
 [ 4  5  6  7  8  9 10]
 [ 5  6  7  8  9 10 11]
 [ 6  7  8  9 10 11 12]]

Recherche des positions optimales de mesure
-------------------------------------------
- Calcul ADAO effectué

Affichage des positions optimales de mesure
-------------------------------------------
- Nombre de positions optimales de mesure..............: 2
- Positions optimales de mesure, numérotées par défaut.: [6 0]

Représentation réduite et informations d'erreurs
------------------------------------------------
- Nombre de vecteurs de la base réduite................: 2
- Vecteurs de la base réduite (un par colonne)

[[ 0.5         1.        ]
 [ 0.58333333  0.83333333]
 [ 0.66666667  0.66666667]
 [ 0.75        0.5       ]
 [ 0.83333333  0.33333333]
 [ 0.91666667  0.16666667]
 [ 1.         -0.        ]]
- Résidus ordonnés d'erreur de reconstruction
  [2.43926218e+01 4.76969601e+00 2.51214793e-15]

- Exemple élémentaire de reconstruction du second champ comme une
  combinaison linéaire des deux vecteurs de base, qui peuvent être
  multipliés par les coefficients respectifs 7.0 et -2.5 :
[[1.]
 [2.]
 [3.]
 [4.]
 [5.]
 [6.]
 [7.]]