From 772b0683c9989daf237ebc7200141ca9489752e0 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Wed, 15 May 2024 20:32:51 +0200 Subject: [PATCH] Minor documentation update and corrections --- .../ref_algorithm_ControledFunctionTest.rst | 16 ++++----- doc/en/ref_algorithm_FunctionTest.rst | 14 ++++---- ...hm_ObservationSimulationComparisonTest.rst | 6 ++-- doc/en/ref_algorithm_ParallelFunctionTest.rst | 14 ++++---- doc/en/ref_algorithm_ReducedModelingTest.rst | 17 +++++---- doc/en/ref_algorithm_SamplingTest.rst | 33 +++++++++++------ doc/en/versions.rst | 9 ++--- .../ref_algorithm_ControledFunctionTest.rst | 16 ++++----- doc/fr/ref_algorithm_FunctionTest.rst | 14 ++++---- ...hm_ObservationSimulationComparisonTest.rst | 6 ++-- doc/fr/ref_algorithm_ParallelFunctionTest.rst | 14 ++++---- doc/fr/ref_algorithm_ReducedModelingTest.rst | 20 +++++------ doc/fr/ref_algorithm_SamplingTest.rst | 35 +++++++++++++------ .../FeaturePropNonLocalOptimization.rst | 7 ++-- doc/fr/versions.rst | 8 ++--- src/daComposant/daCore/BasicObjects.py | 4 +-- 16 files changed, 130 insertions(+), 103 deletions(-) diff --git a/doc/en/ref_algorithm_ControledFunctionTest.rst b/doc/en/ref_algorithm_ControledFunctionTest.rst index ebf5df4..0aafef5 100644 --- a/doc/en/ref_algorithm_ControledFunctionTest.rst +++ b/doc/en/ref_algorithm_ControledFunctionTest.rst @@ -30,14 +30,14 @@ Checking algorithm "*ControledFunctionTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -This verification algorithm allows to analyze in a simple way the stability of -an operator :math:`F` during its execution. The operator is any operator, so it -can be the observation operator :math:`\mathcal{H}` as well as the evolution -operator :math:`\mathcal{D}`, as long as it is provided in each case according -to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is -considered as depending on a vector variable :math:`\mathbf{x}` and on a -control vector variable :math:`\mathbf{u}`, the two not necessarily being of -the same size, and returning another vector variable :math:`\mathbf{y}`. +This algorithm allows to analyze in a simple way the stability of an operator +:math:`F` during its execution. The operator is any operator, so it can be the +observation operator :math:`\mathcal{H}` as well as the evolution operator +:math:`\mathcal{D}`, as long as it is provided in each case according to the +:ref:`section_ref_operator_requirements`. The operator :math:`F` is considered +as depending on a vector variable :math:`\mathbf{x}` and on a control vector +variable :math:`\mathbf{u}`, the two not necessarily being of the same size, +and returning another vector variable :math:`\mathbf{y}`. The algorithm verifies that the operator is working correctly and that its call is compatible with its usage in ADAO algorithms. In practice, it allows to call diff --git a/doc/en/ref_algorithm_FunctionTest.rst b/doc/en/ref_algorithm_FunctionTest.rst index c7ee526..49435d5 100644 --- a/doc/en/ref_algorithm_FunctionTest.rst +++ b/doc/en/ref_algorithm_FunctionTest.rst @@ -30,13 +30,13 @@ Checking algorithm "*FunctionTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -This verification algorithm allows to analyze in a simple way the stability of -an operator :math:`F` during its execution. The operator is any operator, so it -can be the observation operator :math:`\mathcal{H}` as well as the evolution -operator :math:`\mathcal{D}`, as long as it is provided in each case according -to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is -considered as depending on a vector variable :math:`\mathbf{x}` and returning -another vector variable :math:`\mathbf{y}`. +This algorithm allows to analyze in a simple way the stability of an operator +:math:`F` during its execution. The operator is any operator, so it can be the +observation operator :math:`\mathcal{H}` as well as the evolution operator +:math:`\mathcal{D}`, as long as it is provided in each case according to the +:ref:`section_ref_operator_requirements`. The operator :math:`F` is considered +as depending on a vector variable :math:`\mathbf{x}` and returning another +vector variable :math:`\mathbf{y}`. The algorithm verifies that the operator is working correctly and that its call is compatible with its usage in ADAO algorithms. In practice, it allows to call diff --git a/doc/en/ref_algorithm_ObservationSimulationComparisonTest.rst b/doc/en/ref_algorithm_ObservationSimulationComparisonTest.rst index 45e23a8..73ada46 100644 --- a/doc/en/ref_algorithm_ObservationSimulationComparisonTest.rst +++ b/doc/en/ref_algorithm_ObservationSimulationComparisonTest.rst @@ -30,9 +30,9 @@ Checking algorithm "*ObservationSimulationComparisonTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -This verification algorithm allows to analyze in a simple way the stability of -the difference between measures and an operator :math:`F` during its execution. -The operator is any operator, so it can be the observation operator +This algorithm allows to analyze in a simple way the stability of the +difference between measures and an operator :math:`F` during its execution. The +operator is any operator, so it can be the observation operator :math:`\mathcal{H}` as well as the evolution operator :math:`\mathcal{D}`, as long as it is provided in each case according to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is considered diff --git a/doc/en/ref_algorithm_ParallelFunctionTest.rst b/doc/en/ref_algorithm_ParallelFunctionTest.rst index b6872d1..9032724 100644 --- a/doc/en/ref_algorithm_ParallelFunctionTest.rst +++ b/doc/en/ref_algorithm_ParallelFunctionTest.rst @@ -30,13 +30,13 @@ Checking algorithm "*ParallelFunctionTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -This verification algorithm allows to analyze in a simple way the stability of -an operator :math:`F` during its execution in parallel. The operator is any -operator, so it can be the observation operator :math:`\mathcal{H}` as well as -the evolution operator :math:`\mathcal{D}`, as long as it is provided in each -case according to the :ref:`section_ref_operator_requirements`. The operator -:math:`F` is considered as depending on a vector variable :math:`\mathbf{x}` -and returning another vector variable :math:`\mathbf{y}`. +This algorithm allows to analyze in a simple way the stability of an operator +:math:`F` during its execution in parallel. The operator is any operator, so it +can be the observation operator :math:`\mathcal{H}` as well as the evolution +operator :math:`\mathcal{D}`, as long as it is provided in each case according +to the :ref:`section_ref_operator_requirements`. The operator :math:`F` is +considered as depending on a vector variable :math:`\mathbf{x}` and returning +another vector variable :math:`\mathbf{y}`. The algorithm verifies that the operator is working correctly and that its call is compatible with its usage in ADAO algorithms. In practice, it allows to call diff --git a/doc/en/ref_algorithm_ReducedModelingTest.rst b/doc/en/ref_algorithm_ReducedModelingTest.rst index 489d193..a509934 100644 --- a/doc/en/ref_algorithm_ReducedModelingTest.rst +++ b/doc/en/ref_algorithm_ReducedModelingTest.rst @@ -33,15 +33,14 @@ Checking algorithm "*ReducedModelingTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -This checking algorithm provides a simple analysis of the characteristics of -the state collection from the point of view of reduction. It aims to diagnose -the complexity of the information present in the available state collection, -and the possibility to represent this state information in a space smaller than -the entire state collection. Technically, based on a classical SVD (Singular -Value Decomposition) and in the same way as a PCA (Principal Component -Analysis), it evaluates how information decreases with the number of singular -values, either as values or, from a statistical point of view, as remaining -variance. +This algorithm provides a simple analysis of the characteristics of the state +collection from the point of view of reduction. It aims to diagnose the +complexity of the information present in the available state collection, and +the possibility to represent this state information in a space smaller than the +entire state collection. Technically, based on a classical SVD (Singular Value +Decomposition) and in the same way as a PCA (Principal Component Analysis), it +evaluates how information decreases with the number of singular values, either +as values or, from a statistical point of view, as remaining variance. Once the analysis is complete, a summary is displayed and, on request, a graphical representation of the same information is produced. diff --git a/doc/en/ref_algorithm_SamplingTest.rst b/doc/en/ref_algorithm_SamplingTest.rst index f71f0a7..6550dfe 100644 --- a/doc/en/ref_algorithm_SamplingTest.rst +++ b/doc/en/ref_algorithm_SamplingTest.rst @@ -30,15 +30,18 @@ Checking algorithm "*SamplingTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -This test algorithm is used to establish the collection of values of an error -functional :math:`J` of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`, -with or without weights, using the observation operator :math:`\mathcal{H}`, -for an a priori given sample of states :math:`\mathbf{x}`. The default error -functional is the augmented weighted least squares functional, classically used -in data assimilation, using in addition to observations :math:`\mathbf{y}^o`. - -This test is useful for analyzing the sensitivity of the functional :math:`J` -to variations in the state :math:`\mathbf{x}` in particular. +This algorithm establishes the collection of values for any :math:`J` error +functional of type :math:`L^1`, :math:`L^2` or :math:`L^{\infty}`, with or +without weights, as described in the section for +:ref:`section_theory_optimization`. Each :math:`J` calculation is conducted +using the :math:`\mathcal{H}` observation operator and :math:`\mathbf{y}^o` +observations for a :math:`\mathbf{x}` state. The :math:`\mathbf{x}` states come +from a sample of states defined *a priori*. The default error functional is the +augmented weighted least squares functional, classically used in data +assimilation. + +This test is useful for explicitly analyzing the sensitivity of the functional +:math:`J` to variations in the state :math:`\mathbf{x}`. The sampling of the states :math:`\mathbf{x}` can be given explicitly or under form of hypercubes, explicit or sampled according to classic distributions, or @@ -48,7 +51,7 @@ requested by the user. You can refer to the :ref:`section_ref_sampling_requirements` for an illustration of sampling. Beware of the size of the hypercube (and then to the number of computations) that can be reached, it can grow quickly to be quite large. When a state is not -observable, a *"NaN"* value is returned. +observable, a "*NaN*" value is returned. It is also possible to supply a set of simulations :math:`\mathbf{y}` already established elsewhere (so there's no explicit need for an operator @@ -64,6 +67,16 @@ no results are requested, nothing is available). One use for that, on the desired variable, the final saving through "*UserPostAnalysis*" or the treatment during the calculation by well suited "*observer*". +Note: in cases where sampling is generated, it may be useful to explicitly +obtain the collection of states :math:`\mathbf{x}` according to the definition +*a priori* without necessarily performing time-consuming calculations for the +functional :math:`J`. To do this, simply use this algorithm with simplified +calculations. For example, we can define a matrix observation operator equal to +the identity (square matrix of the state size), a draft and an observation +equal, worth 1 (vectors of the state size). Next, we set up the ADAO case with +this algorithm to recover the set of sampled states using the usual +“*CurrentState*” variable. + .. ------------------------------------ .. .. include:: snippets/Header2Algo12.rst diff --git a/doc/en/versions.rst b/doc/en/versions.rst index 2d4658e..4504e0d 100644 --- a/doc/en/versions.rst +++ b/doc/en/versions.rst @@ -60,10 +60,11 @@ However, there may be incompatibilities from user cases written directly in TUI interface. It is advisable to review the syntax and arguments in the TUI scripts at each version change. In particular, it is advisable to check that the algorithm parameters are still adequate and active, knowing that it has -been explicitly chosen that there is no message when a parameter becomes -inactive (for the example, we quote the parameter "*MaximumNumberOfSteps*" as -having changed its name to "*MaximumNumberOfIterations*", for homogeneity with -the variables that can be displayed). +been explicitly chosen that there is no message when an optional parameter +becomes inactive or changes its name (for the example, we quote the parameter +"*MaximumNumberOfSteps*" as having changed its name to +"*MaximumNumberOfIterations*", for homogeneity with the variables that can be +displayed) to avoid a lock. Switching from 8.5 to 9.2 +++++++++++++++++++++++++ diff --git a/doc/fr/ref_algorithm_ControledFunctionTest.rst b/doc/fr/ref_algorithm_ControledFunctionTest.rst index 1fa6a57..f54a973 100644 --- a/doc/fr/ref_algorithm_ControledFunctionTest.rst +++ b/doc/fr/ref_algorithm_ControledFunctionTest.rst @@ -30,14 +30,14 @@ Algorithme de vérification "*ControledFunctionTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -Cet algorithme de vérification permet d'analyser de manière simple la stabilité -d'un opérateur :math:`F` lors de son exécution. L'opérateur est quelconque, et -il peut donc être celui d'observation :math:`\mathcal{H}` comme celui -d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon -les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est -considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et d'un -contrôle :math:`\mathbf{u}`, les deux n'étant pas nécessairement de la même -taille, et restituant une autre variable vectorielle :math:`\mathbf{y}`. +Cet algorithme permet d'analyser de manière simple la stabilité d'un opérateur +:math:`F` lors de son exécution. L'opérateur est quelconque, et il peut donc +être celui d'observation :math:`\mathcal{H}` comme celui d'évolution +:math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon les +:ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est considéré +comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et d'un contrôle +:math:`\mathbf{u}`, les deux n'étant pas nécessairement de la même taille, et +restituant une autre variable vectorielle :math:`\mathbf{y}`. L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De diff --git a/doc/fr/ref_algorithm_FunctionTest.rst b/doc/fr/ref_algorithm_FunctionTest.rst index 2429a04..0f1a8c6 100644 --- a/doc/fr/ref_algorithm_FunctionTest.rst +++ b/doc/fr/ref_algorithm_FunctionTest.rst @@ -30,13 +30,13 @@ Algorithme de vérification "*FunctionTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -Cet algorithme de vérification permet d'analyser de manière simple la stabilité -d'un opérateur :math:`F` lors de son exécution. L'opérateur est quelconque, et -il peut donc être celui d'observation :math:`\mathcal{H}` comme celui -d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon -les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est -considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et -restituant une autre variable vectorielle :math:`\mathbf{y}`. +Cet algorithme permet d'analyser de manière simple la stabilité d'un opérateur +:math:`F` lors de son exécution. L'opérateur est quelconque, et il peut donc +être celui d'observation :math:`\mathcal{H}` comme celui d'évolution +:math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon les +:ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est considéré +comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et restituant une +autre variable vectorielle :math:`\mathbf{y}`. L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De diff --git a/doc/fr/ref_algorithm_ObservationSimulationComparisonTest.rst b/doc/fr/ref_algorithm_ObservationSimulationComparisonTest.rst index 88665a8..5e8380f 100644 --- a/doc/fr/ref_algorithm_ObservationSimulationComparisonTest.rst +++ b/doc/fr/ref_algorithm_ObservationSimulationComparisonTest.rst @@ -30,9 +30,9 @@ Algorithme de vérification "*ObservationSimulationComparisonTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -Cet algorithme de vérification permet d'analyser de manière simple la stabilité -de l'écart entre des mesures et le calcul d'un opérateur :math:`F`, lors de son -exécution. L'opérateur est quelconque, et il peut donc être celui d'observation +Cet algorithme permet d'analyser de manière simple la stabilité de l'écart +entre des mesures et le calcul d'un opérateur :math:`F`, lors de son exécution. +L'opérateur est quelconque, et il peut donc être celui d'observation :math:`\mathcal{H}` comme celui d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est considéré comme dépendant d'une variable vectorielle diff --git a/doc/fr/ref_algorithm_ParallelFunctionTest.rst b/doc/fr/ref_algorithm_ParallelFunctionTest.rst index a888314..f8dd610 100644 --- a/doc/fr/ref_algorithm_ParallelFunctionTest.rst +++ b/doc/fr/ref_algorithm_ParallelFunctionTest.rst @@ -30,13 +30,13 @@ Algorithme de vérification "*ParallelFunctionTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -Cet algorithme de vérification permet d'analyser de manière simple la stabilité -d'un opérateur :math:`F` lors de son exécution en parallèle. L'opérateur est -quelconque, et il peut donc être celui d'observation :math:`\mathcal{H}` comme -celui d'évolution :math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas -selon les :ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est -considéré comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et -restituant une autre variable vectorielle :math:`\mathbf{y}`. +Cet algorithme permet d'analyser de manière simple la stabilité d'un opérateur +:math:`F` lors de son exécution en parallèle. L'opérateur est quelconque, et il +peut donc être celui d'observation :math:`\mathcal{H}` comme celui d'évolution +:math:`\mathcal{D}`, pourvu qu'il soit fourni dans chaque cas selon les +:ref:`section_ref_operator_requirements`. L'opérateur :math:`F` est considéré +comme dépendant d'une variable vectorielle :math:`\mathbf{x}` et restituant une +autre variable vectorielle :math:`\mathbf{y}`. L'algorithme vérifie que l'opérateur fonctionne correctement et que son appel se déroule de manière compatible avec son usage dans les algorithmes d'ADAO. De diff --git a/doc/fr/ref_algorithm_ReducedModelingTest.rst b/doc/fr/ref_algorithm_ReducedModelingTest.rst index c797655..de02d18 100644 --- a/doc/fr/ref_algorithm_ReducedModelingTest.rst +++ b/doc/fr/ref_algorithm_ReducedModelingTest.rst @@ -33,16 +33,16 @@ Algorithme de vérification "*ReducedModelingTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -Cet algorithme de vérification permet d'analyser de manière simple les -caractéristiques de la collection d'états du point de vue de la réduction. Il -vise à diagnostiquer la complexité des informations présentes dans la -collection d'états disponible, et la possibilité de représenter ces -informations d'état dans un espace plus réduit que l'ensemble de la collection -d'états. Techniquement, en s'appuyant sur une décomposition classique de type -SVD (Singular Value Decomposition) et de la même manière qu'une PCA (Principal -Component Analysis), il évalue la manière avec laquelle l'information diminue -avec le nombre de valeurs singulières, soit en tant que valeurs, soit, d'un -point de vue statistique, en tant que variance restante. +Cet algorithme permet d'analyser de manière simple les caractéristiques de la +collection d'états du point de vue de la réduction. Il vise à diagnostiquer la +complexité des informations présentes dans la collection d'états disponible, et +la possibilité de représenter ces informations d'état dans un espace plus +réduit que l'ensemble de la collection d'états. Techniquement, en s'appuyant +sur une décomposition classique de type SVD (Singular Value Decomposition) et +de la même manière qu'une PCA (Principal Component Analysis), il évalue la +manière avec laquelle l'information diminue avec le nombre de valeurs +singulières, soit en tant que valeurs, soit, d'un point de vue statistique, en +tant que variance restante. Une fois l'analyse terminée, un résumé est affiché et, sur demande, une représentation graphique des mêmes informations est produite. diff --git a/doc/fr/ref_algorithm_SamplingTest.rst b/doc/fr/ref_algorithm_SamplingTest.rst index 8101d17..9c1808a 100644 --- a/doc/fr/ref_algorithm_SamplingTest.rst +++ b/doc/fr/ref_algorithm_SamplingTest.rst @@ -30,16 +30,18 @@ Algorithme de vérification "*SamplingTest*" .. ------------------------------------ .. .. include:: snippets/Header2Algo01.rst -Cet algorithme de test permet d'établir la collection des valeurs d'une -fonctionnelle d'erreur :math:`J` de type :math:`L^1`, :math:`L^2` ou -:math:`L^{\infty}`, avec ou sans pondérations, à l'aide de l'opérateur -d'observation :math:`\mathcal{H}`, pour un échantillon donné a priori d'états -:math:`\mathbf{x}`. La fonctionnelle d'erreur par défaut est celle de moindres -carrés pondérés augmentés, classiquement utilisée en assimilation de données, -utilisant en plus des observations :math:`\mathbf{y}^o`. - -Ce test est utile pour analyser la sensibilité de la fonctionnelle :math:`J` -aux variations de l'état :math:`\mathbf{x}` en particulier. +Cet algorithme permet d'établir la collection des valeurs d'une fonctionnelle +d'erreur :math:`J` quelconque de type :math:`L^1`, :math:`L^2` ou +:math:`L^{\infty}`, avec ou sans pondérations, comme décrit dans la section +pour :ref:`section_theory_optimization`. Chaque calcul de :math:`J` est conduit +à l'aide de l'opérateur d'observation :math:`\mathcal{H}` et des observations +:math:`\mathbf{y}^o` pour un état :math:`\mathbf{x}`. Les états +:math:`\mathbf{x}` proviennent d'un échantillon d'états défini *a priori*. La +fonctionnelle d'erreur par défaut est celle de moindres carrés pondérés +augmentés, classiquement utilisée en assimilation de données. + +Ce test est utile pour analyser explicitement la sensibilité de la +fonctionnelle :math:`J` aux variations de l'état :math:`\mathbf{x}`. L'échantillonnage des états :math:`\mathbf{x}` peut être fourni explicitement ou sous la forme d'hypercubes, explicites ou échantillonnés selon des @@ -49,7 +51,7 @@ informatiques disponibles et les options demandées par l'utilisateur. On pourra se reporter aux :ref:`section_ref_sampling_requirements` 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. Lorsqu'un état n'est pas observable, une valeur *"NaN"* est +importante. Lorsqu'un état n'est pas observable, une valeur "*NaN*" est retournée. Il est aussi possible de fournir un ensemble de simulations :math:`\mathbf{y}` @@ -67,6 +69,17 @@ disponible). On utilise pour cela, sur la variable désirée, la sauvegarde finale à l'aide du mot-clé "*UserPostAnalysis*" ou le traitement en cours de calcul à l'aide des "*observer*" adaptés. +Remarque : dans les cas où l'échantillonnage est généré, il peut être utile +d'obtenir explicitement la collection des états :math:`\mathbf{x}` selon la +définition *a priori* sans nécessairement effectuer de long calculs pour la +fonctionnelle :math:`J`. Pour cela, il suffit d'utiliser cet algorithme avec +des calculs simplifiés. Par exemple, on peut définir un opérateur d'observation +matriciel égal à l'identité (matrice carrée de la taille d'un état), une +ébauche et une observation égales, valant 1 (vecteurs de la taille de l'état). +Ensuite, on établit le cas ADAO avec cet algorithme pour récupérer l'ensemble +des états échantillonnés à l'aide de la variable habituelle de +"*CurrentState*". + .. ------------------------------------ .. .. include:: snippets/Header2Algo12.rst diff --git a/doc/fr/snippets/FeaturePropNonLocalOptimization.rst b/doc/fr/snippets/FeaturePropNonLocalOptimization.rst index d5f7d80..e51691b 100644 --- a/doc/fr/snippets/FeaturePropNonLocalOptimization.rst +++ b/doc/fr/snippets/FeaturePropNonLocalOptimization.rst @@ -2,6 +2,7 @@ - Les méthodes d'optimisation proposées par cet algorithme effectuent une **recherche non locale du minimum**, sans pour autant néanmoins assurer une - recherche globale. C'est le cas lorsque les méthodes d'optimisation - présentent des capacités d'éviter de rester bloquées par le premier minimum - local trouvé. Ces capacités sont parfois heuristiques. + recherche globale. C'est le cas lorsque les méthodes d'optimisation de + recherche locale présentent de plus des capacités permettant d'éviter de + rester bloquées par le premier minimum local trouvé. Ces capacités sont + parfois heuristiques. diff --git a/doc/fr/versions.rst b/doc/fr/versions.rst index de2983d..d9e1e9f 100644 --- a/doc/fr/versions.rst +++ b/doc/fr/versions.rst @@ -62,10 +62,10 @@ utilisateurs écrits directement en interface TUI. Il est conseillé de revoir l syntaxe et les arguments dans les scripts TUI à chaque changement de version. En particulier, il convient de vérifier que les paramètres d'algorithme sont toujours adéquats et actifs, sachant qu'il a été explicitement choisi qu'il n'y -ait pas de message lorsqu'un paramètre devient inactif (pour l'exemple, on cite -le paramètre "*MaximumNumberOfSteps*" comme ayant changé de nom pour devenir -"*MaximumNumberOfIterations*", par homogénéité avec les variables pouvant être -affichées). +ait pas de message lorsqu'un paramètre optionnel devient inactif ou change de +nom (pour l'exemple, on cite le paramètre "*MaximumNumberOfSteps*" comme ayant +changé de nom pour devenir "*MaximumNumberOfIterations*", par homogénéité avec +les variables pouvant être affichées) pour éviter un blocage. Passer de la version 8.5 à la 9.2 +++++++++++++++++++++++++++++++++ diff --git a/src/daComposant/daCore/BasicObjects.py b/src/daComposant/daCore/BasicObjects.py index 1ece284..60a478c 100644 --- a/src/daComposant/daCore/BasicObjects.py +++ b/src/daComposant/daCore/BasicObjects.py @@ -452,7 +452,7 @@ class FullOperator(object): # __Parameters = {} if (asDict is not None) and isinstance(asDict, dict): - __Parameters.update( asDict ) + __Parameters.update( asDict ) # Copie mémoire # Deprecated parameters __Parameters = self.__deprecateOpt( collection = __Parameters, @@ -874,7 +874,7 @@ class Algorithm(object): # # Mise à jour des paramètres internes avec le contenu de Parameters, en # reprenant les valeurs par défauts pour toutes celles non définies - self.__setParameters(Parameters, reset=True) # Copie + self.__setParameters(Parameters, reset=True) # Copie mémoire for k, v in self.__variable_names_not_public.items(): if k not in self._parameters: self.__setParameters( {k: v} ) -- 2.39.2