From 38f445a5d6ef73ccb309423dfb700a1095b727a4 Mon Sep 17 00:00:00 2001 From: Jean-Philippe ARGAUD Date: Tue, 26 Aug 2014 21:37:59 +0200 Subject: [PATCH] Adding examples for each optional command --- doc/en/ref_algorithm_3DVAR.rst | 16 +++++++++ doc/en/ref_algorithm_AdjointTest.rst | 8 +++++ doc/en/ref_algorithm_Blue.rst | 4 +++ doc/en/ref_algorithm_EnsembleBlue.rst | 2 ++ doc/en/ref_algorithm_ExtendedBlue.rst | 4 +++ doc/en/ref_algorithm_ExtendedKalmanFilter.rst | 10 ++++-- doc/en/ref_algorithm_FunctionTest.rst | 12 +++++-- doc/en/ref_algorithm_GradientTest.rst | 12 ++++++- doc/en/ref_algorithm_KalmanFilter.rst | 6 ++++ doc/en/ref_algorithm_LinearLeastSquares.rst | 4 +++ doc/en/ref_algorithm_LinearityTest.rst | 12 ++++++- .../ref_algorithm_NonLinearLeastSquares.rst | 16 +++++++++ doc/en/ref_algorithm_ObserverTest.rst | 4 +-- ...ef_algorithm_ParticleSwarmOptimization.rst | 22 ++++++++++-- doc/en/ref_algorithm_QuantileRegression.rst | 10 ++++++ doc/en/ref_algorithm_SamplingTest.rst | 16 +++++++-- doc/en/ref_algorithm_TangentTest.rst | 8 +++++ .../ref_algorithm_UnscentedKalmanFilter.rst | 14 +++++--- doc/fr/ref_algorithm_3DVAR.rst | 36 +++++++++++++------ doc/fr/ref_algorithm_AdjointTest.rst | 8 +++++ doc/fr/ref_algorithm_Blue.rst | 4 +++ doc/fr/ref_algorithm_EnsembleBlue.rst | 4 ++- doc/fr/ref_algorithm_ExtendedBlue.rst | 4 +++ doc/fr/ref_algorithm_ExtendedKalmanFilter.rst | 10 ++++-- doc/fr/ref_algorithm_FunctionTest.rst | 8 ++++- doc/fr/ref_algorithm_GradientTest.rst | 12 ++++++- doc/fr/ref_algorithm_KalmanFilter.rst | 6 ++++ doc/fr/ref_algorithm_LinearLeastSquares.rst | 4 +++ doc/fr/ref_algorithm_LinearityTest.rst | 10 ++++++ .../ref_algorithm_NonLinearLeastSquares.rst | 16 +++++++++ ...ef_algorithm_ParticleSwarmOptimization.rst | 20 ++++++++++- doc/fr/ref_algorithm_QuantileRegression.rst | 10 ++++++ doc/fr/ref_algorithm_SamplingTest.rst | 12 ++++++- doc/fr/ref_algorithm_TangentTest.rst | 8 +++++ .../ref_algorithm_UnscentedKalmanFilter.rst | 12 +++++-- 35 files changed, 324 insertions(+), 40 deletions(-) diff --git a/doc/en/ref_algorithm_3DVAR.rst b/doc/en/ref_algorithm_3DVAR.rst index 5d3f73a..1db7125 100644 --- a/doc/en/ref_algorithm_3DVAR.rst +++ b/doc/en/ref_algorithm_3DVAR.rst @@ -107,6 +107,8 @@ The options of the algorithm are the following: (nonlinear unconstrained minimizer), "NCG" (Newton CG minimizer). It is strongly recommended to stay with the default. + Example : ``{"Minimizer":"LBFGSB"}`` + Bounds This key allows to define upper and lower bounds for every state variable being optimized. Bounds have to be given by a list of list of pairs of @@ -114,6 +116,8 @@ The options of the algorithm are the following: there is no bound. The bounds can always be specified, but they are taken into account only by the constrained optimizers. + Example : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` + MaximumNumberOfSteps This key indicates the maximum number of iterations allowed for iterative optimization. The default is 15000, which is very similar to no limit on @@ -122,12 +126,16 @@ The options of the algorithm are the following: slightly different of the limit due to algorithm internal control requirements. + Example : ``{"MaximumNumberOfSteps":100}`` + CostDecrementTolerance This key indicates a limit value, leading to stop successfully the iterative optimization process when the cost function decreases less than this tolerance at the last step. The default is 1.e-7, and it is recommended to adapt it to the needs on real problems. + Example : ``{"CostDecrementTolerance":1.e-7}`` + ProjectedGradientTolerance This key indicates a limit value, leading to stop successfully the iterative optimization process when all the components of the projected gradient are @@ -135,18 +143,24 @@ The options of the algorithm are the following: -1, that is the internal default of each minimizer (generally 1.e-5), and it is not recommended to change it. + Example : ``{"ProjectedGradientTolerance":-1}`` + GradientNormTolerance This key indicates a limit value, leading to stop successfully the iterative optimization process when the norm of the gradient is under this limit. It is only used for non-constrained optimizers. The default is 1.e-5 and it is not recommended to change it. + Example : ``{"GradientNormTolerance":1.e-5}`` + StoreInternalVariables This Boolean key allows to store default internal variables, mainly the current state during iterative optimization process. Be careful, this can be a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -155,6 +169,8 @@ The options of the algorithm are the following: are in the following list: ["APosterioriCovariance", "BMA", "OMA", "OMB", "Innovation", "SigmaObs2", "MahalanobisConsistency"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_AdjointTest.rst b/doc/en/ref_algorithm_AdjointTest.rst index dfdb9b0..e7916e8 100644 --- a/doc/en/ref_algorithm_AdjointTest.rst +++ b/doc/en/ref_algorithm_AdjointTest.rst @@ -86,6 +86,8 @@ The options of the algorithm are the following: used for the directional derivative around the nominal checking point. The default is 1, that means no scaling. + Example : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent This key indicates the minimal exponent value of the power of 10 coefficient to be used to decrease the increment multiplier. The default is -8, and it @@ -93,18 +95,24 @@ The options of the algorithm are the following: calculate the residue of the formula with a fixed increment multiplied from 1.e0 to 1.e-8. + Example : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection This key indicates the vector direction used for the directional derivative around the nominal checking point. It has to be a vector. If not specified, this direction defaults to a random perturbation around zero of the same vector size than the checking point. + Example : ``{"InitialDirection":[0.1,0.1,100.,3}`` + SetSeed This key allow to give an integer in order to fix the seed of the random generator used to generate the ensemble. A convenient value is for example 1000. By default, the seed is left uninitialized, and so use the default initialization from the computer. + Example : ``{"SetSeed":1000}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_Blue.rst b/doc/en/ref_algorithm_Blue.rst index 2ccead4..27f2088 100644 --- a/doc/en/ref_algorithm_Blue.rst +++ b/doc/en/ref_algorithm_Blue.rst @@ -104,6 +104,8 @@ The options of the algorithm are the following: a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -112,6 +114,8 @@ The options of the algorithm are the following: are in the following list: ["APosterioriCovariance", "BMA", "OMA", "OMB", "Innovation", "SigmaBck2", "SigmaObs2", "MahalanobisConsistency"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_EnsembleBlue.rst b/doc/en/ref_algorithm_EnsembleBlue.rst index 2ee3a74..9ec4bbf 100644 --- a/doc/en/ref_algorithm_EnsembleBlue.rst +++ b/doc/en/ref_algorithm_EnsembleBlue.rst @@ -100,6 +100,8 @@ The options of the algorithm are the following: 1000. By default, the seed is left uninitialized, and so use the default initialization from the computer. + Example : ``{"SetSeed":1000}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_ExtendedBlue.rst b/doc/en/ref_algorithm_ExtendedBlue.rst index 3df0b59..2337cdd 100644 --- a/doc/en/ref_algorithm_ExtendedBlue.rst +++ b/doc/en/ref_algorithm_ExtendedBlue.rst @@ -102,6 +102,8 @@ The options of the algorithm are the following: a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -110,6 +112,8 @@ The options of the algorithm are the following: are in the following list: ["APosterioriCovariance", "BMA", "OMA", "OMB", "Innovation", "SigmaBck2", "SigmaObs2", "MahalanobisConsistency"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst index fb8404e..60586e5 100644 --- a/doc/en/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/en/ref_algorithm_ExtendedKalmanFilter.rst @@ -97,21 +97,23 @@ The options of the algorithm are the following: lower/upper bounds for each variable, with extreme values every time there is no bound (``None`` is not allowed when there is no bound). - ConstrainedBy - This key allows to define the method to take bounds into account. The - possible methods are in the following list: ["EstimateProjection"]. + Example : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,1.e99],[-1.e99,1.e99]]}`` EstimationOf This key allows to choose the type of estimation to be performed. It can be either state-estimation, with a value of "State", or parameter-estimation, with a value of "Parameters". The default choice is "State". + Example : ``{"EstimationOf":"Parameters"}`` + StoreInternalVariables This Boolean key allows to store default internal variables, mainly the current state during iterative optimization process. Be careful, this can be a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -119,6 +121,8 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["APosterioriCovariance", "BMA", "Innovation"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_FunctionTest.rst b/doc/en/ref_algorithm_FunctionTest.rst index 4a88614..7411e49 100644 --- a/doc/en/ref_algorithm_FunctionTest.rst +++ b/doc/en/ref_algorithm_FunctionTest.rst @@ -24,8 +24,8 @@ .. index:: single: FunctionTest .. _section_ref_algorithm_FunctionTest: -Checking algorithm "FunctionTest" ---------------------------------- +Checking algorithm "*FunctionTest*" +----------------------------------- Description +++++++++++ @@ -80,15 +80,21 @@ The options of the algorithm are the following: This key indicates the number of digits of precision for floating point printed output. The default is 5, with a minimum of 0. + Example : ``{"NumberOfPrintedDigits":5}`` + NumberOfRepetition This key indicates the number of time to repeat the function evaluation. The default is 1. - + + Example : ``{"NumberOfRepetition":3}`` + SetDebug This key requires the activation, or not, of the debug mode during the function evaluation. The default is "True", the choices are "True" or "False". + Example : ``{"SetDebug":False}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_GradientTest.rst b/doc/en/ref_algorithm_GradientTest.rst index cf45bda..99fe344 100644 --- a/doc/en/ref_algorithm_GradientTest.rst +++ b/doc/en/ref_algorithm_GradientTest.rst @@ -103,6 +103,8 @@ The options of the algorithm are the following: used for the directional derivative around the nominal checking point. The default is 1, that means no scaling. + Example : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent This key indicates the minimal exponent value of the power of 10 coefficient to be used to decrease the increment multiplier. The default is -8, and it @@ -110,12 +112,16 @@ The options of the algorithm are the following: calculate the residue of the scalar product formula with a fixed increment multiplied from 1.e0 to 1.e-8. + Example : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection This key indicates the vector direction used for the directional derivative around the nominal checking point. It has to be a vector. If not specified, this direction defaults to a random perturbation around zero of the same vector size than the checking point. + Example : ``{"InitialDirection":[0.1,0.1,100.,3}`` + ResiduFormula This key indicates the residue formula that has to be used for the test. The default choice is "Taylor", and the possible ones are "Taylor" (residue of @@ -123,13 +129,17 @@ The options of the algorithm are the following: square power of the perturbation) and "Norm" (residue obtained by taking the norm of the Taylor development at zero order approximation, which approximate the gradient, and which has to remain constant). - + + Example : ``{"ResiduFormula":"Taylor"}`` + SetSeed This key allow to give an integer in order to fix the seed of the random generator used to generate the ensemble. A convenient value is for example 1000. By default, the seed is left uninitialized, and so use the default initialization from the computer. + Example : ``{"SetSeed":1000}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_KalmanFilter.rst b/doc/en/ref_algorithm_KalmanFilter.rst index 51f0df6..ee5e0df 100644 --- a/doc/en/ref_algorithm_KalmanFilter.rst +++ b/doc/en/ref_algorithm_KalmanFilter.rst @@ -103,12 +103,16 @@ The options of the algorithm are the following: either state-estimation, with a value of "State", or parameter-estimation, with a value of "Parameters". The default choice is "State". + Example : ``{"EstimationOf":"Parameters"}`` + StoreInternalVariables This Boolean key allows to store default internal variables, mainly the current state during iterative optimization process. Be careful, this can be a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -116,6 +120,8 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["APosterioriCovariance", "BMA", "Innovation"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_LinearLeastSquares.rst b/doc/en/ref_algorithm_LinearLeastSquares.rst index ed3c714..a0863ec 100644 --- a/doc/en/ref_algorithm_LinearLeastSquares.rst +++ b/doc/en/ref_algorithm_LinearLeastSquares.rst @@ -93,6 +93,8 @@ The options of the algorithm are the following: a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -100,6 +102,8 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["OMA"]. + Example : ``{"StoreSupplementaryCalculations":["OMA"]}`` + *Tips for this algorithm:* As the *"Background"* and *"BackgroundError"* commands are required for ALL diff --git a/doc/en/ref_algorithm_LinearityTest.rst b/doc/en/ref_algorithm_LinearityTest.rst index 6465747..91323e7 100644 --- a/doc/en/ref_algorithm_LinearityTest.rst +++ b/doc/en/ref_algorithm_LinearityTest.rst @@ -152,6 +152,8 @@ The options of the algorithm are the following: used for the directional derivative around the nominal checking point. The default is 1, that means no scaling. + Example : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent This key indicates the minimal exponent value of the power of 10 coefficient to be used to decrease the increment multiplier. The default is -8, and it @@ -159,12 +161,16 @@ The options of the algorithm are the following: calculate the residue of the scalar product formula with a fixed increment multiplied from 1.e0 to 1.e-8. + Example : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection This key indicates the vector direction used for the directional derivative around the nominal checking point. It has to be a vector. If not specified, this direction defaults to a random perturbation around zero of the same vector size than the checking point. + Example : ``{"InitialDirection":[0.1,0.1,100.,3}`` + ResiduFormula This key indicates the residue formula that has to be used for the test. The default choice is "CenteredDL", and the possible ones are "CenteredDL" @@ -176,13 +182,17 @@ The options of the algorithm are the following: point, which has to stay close to 1), and "NominalTaylorRMS" (residue of the order 1 approximations of the operator, normalized by RMS to the nominal point, which has to stay close to 0). - + + Example : ``{"ResiduFormula":"CenteredDL"}`` + SetSeed This key allow to give an integer in order to fix the seed of the random generator used to generate the ensemble. A convenient value is for example 1000. By default, the seed is left uninitialized, and so use the default initialization from the computer. + Example : ``{"SetSeed":1000}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_NonLinearLeastSquares.rst b/doc/en/ref_algorithm_NonLinearLeastSquares.rst index 77e15e8..5130425 100644 --- a/doc/en/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/en/ref_algorithm_NonLinearLeastSquares.rst @@ -104,6 +104,8 @@ The options of the algorithm are the following: (nonlinear unconstrained minimizer), "NCG" (Newton CG minimizer). It is strongly recommended to stay with the default. + Example : ``{"Minimizer":"LBFGSB"}`` + Bounds This key allows to define upper and lower bounds for every state variable being optimized. Bounds have to be given by a list of list of pairs of @@ -111,6 +113,8 @@ The options of the algorithm are the following: there is no bound. The bounds can always be specified, but they are taken into account only by the constrained optimizers. + Example : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` + MaximumNumberOfSteps This key indicates the maximum number of iterations allowed for iterative optimization. The default is 15000, which is very similar to no limit on @@ -118,12 +122,16 @@ The options of the algorithm are the following: real problems. For some optimizers, the effective stopping step can be slightly different due to algorithm internal control requirements. + Example : ``{"MaximumNumberOfSteps":100}`` + CostDecrementTolerance This key indicates a limit value, leading to stop successfully the iterative optimization process when the cost function decreases less than this tolerance at the last step. The default is 1.e-7, and it is recommended to adapt it to the needs on real problems. + Example : ``{"CostDecrementTolerance":1.e-7}`` + ProjectedGradientTolerance This key indicates a limit value, leading to stop successfully the iterative optimization process when all the components of the projected gradient are @@ -131,18 +139,24 @@ The options of the algorithm are the following: -1, that is the internal default of each minimizer (generally 1.e-5), and it is not recommended to change it. + Example : ``{"ProjectedGradientTolerance":-1}`` + GradientNormTolerance This key indicates a limit value, leading to stop successfully the iterative optimization process when the norm of the gradient is under this limit. It is only used for non-constrained optimizers. The default is 1.e-5 and it is not recommended to change it. + Example : ``{"GradientNormTolerance":1.e-5}`` + StoreInternalVariables This Boolean key allows to store default internal variables, mainly the current state during iterative optimization process. Be careful, this can be a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -150,6 +164,8 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["BMA", "OMA", "OMB", "Innovation"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + *Tips for this algorithm:* As the *"BackgroundError"* command is required for ALL the calculation diff --git a/doc/en/ref_algorithm_ObserverTest.rst b/doc/en/ref_algorithm_ObserverTest.rst index 7c00b68..a75d907 100644 --- a/doc/en/ref_algorithm_ObserverTest.rst +++ b/doc/en/ref_algorithm_ObserverTest.rst @@ -24,8 +24,8 @@ .. index:: single: ObserverTest .. _section_ref_algorithm_ObserverTest: -Checking algorithm "ObserverTest" ---------------------------------- +Checking algorithm "*ObserverTest*" +----------------------------------- Description +++++++++++ diff --git a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst index 9979800..016b265 100644 --- a/doc/en/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/en/ref_algorithm_ParticleSwarmOptimization.rst @@ -104,18 +104,26 @@ The options of the algorithm are the following: optimization. The default is 50, which is an arbitrary limit. It is then recommended to adapt this parameter to the needs on real problems. + Example : ``{"MaximumNumberOfSteps":100}`` + NumberOfInsects This key indicates the number of insects or particles in the swarm. The default is 100, which is a usual default for this algorithm. + Example : ``{"NumberOfInsects":100}`` + SwarmVelocity This key indicates the part of the insect velocity which is imposed by the swarm. It is a positive floating point value. The default value is 1. + Example : ``{"SwarmVelocity":1.}`` + GroupRecallRate This key indicates the recall rate at the best swarm insect. It is a floating point value between 0 and 1. The default value is 0.5. + Example : ``{"GroupRecallRate":0.5}`` + QualityCriterion This key indicates the quality criterion, minimized to find the optimal state estimate. The default is the usual data assimilation criterion named @@ -123,8 +131,10 @@ The options of the algorithm are the following: in the following list, where the equivalent names are indicated by the sign "=": ["AugmentedWeightedLeastSquares"="AWLS"="DA", "WeightedLeastSquares"="WLS", "LeastSquares"="LS"="L2", - "AbsoluteValue"="L1", "MaximumError"="ME"] - + "AbsoluteValue"="L1", "MaximumError"="ME"]. + + Example : ``{"QualityCriterion":"DA"}`` + BoxBounds This key allows to define upper and lower bounds for *increments* on every state variable being optimized (and not on state variables themselves). @@ -133,18 +143,24 @@ The options of the algorithm are the following: (``None`` is not allowed when there is no bound). This key is required and there is no default values. + Example : ``{"BoxBounds":[[-0.5,0.5],[0.01,2.],[0.,1.e99],[-1.e99,1.e99]]}`` + SetSeed This key allow to give an integer in order to fix the seed of the random generator used to generate the ensemble. A convenient value is for example 1000. By default, the seed is left uninitialized, and so use the default initialization from the computer. + Example : ``{"SetSeed":1000}`` + StoreInternalVariables This Boolean key allows to store default internal variables, mainly the current state during iterative optimization process. Be careful, this can be a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -152,6 +168,8 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["BMA", "OMA", "OMB", "Innovation"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_QuantileRegression.rst b/doc/en/ref_algorithm_QuantileRegression.rst index f27e6a1..93d3b6f 100644 --- a/doc/en/ref_algorithm_QuantileRegression.rst +++ b/doc/en/ref_algorithm_QuantileRegression.rst @@ -84,24 +84,32 @@ The options of the algorithm are the following: This key allows to define the real value of the desired quantile, between 0 and 1. The default is 0.5, corresponding to the median. + Example : ``{"Quantile":0.5}`` + MaximumNumberOfSteps This key indicates the maximum number of iterations allowed for iterative optimization. The default is 15000, which is very similar to no limit on iterations. It is then recommended to adapt this parameter to the needs on real problems. + Example : ``{"MaximumNumberOfSteps":100}`` + CostDecrementTolerance This key indicates a limit value, leading to stop successfully the iterative optimization process when the cost function or the surrogate decreases less than this tolerance at the last step. The default is 1.e-6, and it is recommended to adapt it to the needs on real problems. + Example : ``{"CostDecrementTolerance":1.e-7}`` + StoreInternalVariables This Boolean key allows to store default internal variables, mainly the current state during iterative optimization process. Be careful, this can be a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -109,6 +117,8 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["BMA", "OMA", "OMB", "Innovation"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + *Tips for this algorithm:* As the *"BackgroundError"* and *"ObservationError"* commands are required diff --git a/doc/en/ref_algorithm_SamplingTest.rst b/doc/en/ref_algorithm_SamplingTest.rst index 4a0114f..aa1910e 100644 --- a/doc/en/ref_algorithm_SamplingTest.rst +++ b/doc/en/ref_algorithm_SamplingTest.rst @@ -24,8 +24,8 @@ .. index:: single: SamplingTest .. _section_ref_algorithm_SamplingTest: -Checking algorithm "SamplingTest" ---------------------------------- +Checking algorithm "*SamplingTest*" +----------------------------------- Description +++++++++++ @@ -102,21 +102,29 @@ The options of the algorithm are the following: This key describes the calculations points as a list of n-uplets, each n-uplet being a state. + Example : ``{"SampleAsnUplet":[[0,1,2,3],[4,3,2,1],[-2,3,-4,5]]}`` for 3 points in a state space of dimension 4 + SampleAsExplicitHyperCube This key describes the calculations points as an hypercube, from which one gives the list of sampling of each variable as a list. That is then a list of lists, each of them being potentially of different size. + Example : ``{"SampleAsExplicitHyperCube":[[0.,0.25,0.5,0.75,1.],[-2,2,1]]}`` for a state space of dimension 2 + SampleAsMinMaxStepHyperCube This key describes the calculations points as an hypercube from which one the sampling of each variable by a triplet *[min,max,step]*. That is then a - list of the same size then the one of the state. + list of the same size than the one of the state. The bounds are included. + + Example : ``{"SampleAsMinMaxStepHyperCube":[[0.,1.,0.25],[-1,3,1]]}`` for a state space of dimension 2 SetDebug This key requires the activation, or not, of the debug mode during the function evaluation. The default is "True", the choices are "True" or "False". + Example : ``{"SetDebug":False}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -125,6 +133,8 @@ The options of the algorithm are the following: are in the following list: ["CostFunctionJ", "CurrentState", "Innovation", "ObservedState"]. + Example : ``{"StoreSupplementaryCalculations":["CostFunctionJ", "ObservedState"]}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_TangentTest.rst b/doc/en/ref_algorithm_TangentTest.rst index 4f83d15..a1daea7 100644 --- a/doc/en/ref_algorithm_TangentTest.rst +++ b/doc/en/ref_algorithm_TangentTest.rst @@ -94,6 +94,8 @@ The options of the algorithm are the following: used for the directional derivative around the nominal checking point. The default is 1, that means no scaling. + Example : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent This key indicates the minimal exponent value of the power of 10 coefficient to be used to decrease the increment multiplier. The default is -8, and it @@ -101,18 +103,24 @@ The options of the algorithm are the following: calculate the residue of the scalar product formula with a fixed increment multiplied from 1.e0 to 1.e-8. + Example : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection This key indicates the vector direction used for the directional derivative around the nominal checking point. It has to be a vector. If not specified, this direction defaults to a random perturbation around zero of the same vector size than the checking point. + Example : ``{"InitialDirection":[0.1,0.1,100.,3}`` + SetSeed This key allow to give an integer in order to fix the seed of the random generator used to generate the ensemble. A convenient value is for example 1000. By default, the seed is left uninitialized, and so use the default initialization from the computer. + Example : ``{"SetSeed":1000}`` + See also ++++++++ diff --git a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst index b27c4a5..1b782c9 100644 --- a/doc/en/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/en/ref_algorithm_UnscentedKalmanFilter.rst @@ -103,15 +103,15 @@ The options of the algorithm are the following: lower/upper bounds for each variable, with extreme values every time there is no bound (``None`` is not allowed when there is no bound). - ConstrainedBy - This key allows to define the method to take bounds into account. The - possible methods are in the following list: ["EstimateProjection"]. + Example : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,1.e99],[-1.e99,1.e99]]}`` EstimationOf This key allows to choose the type of estimation to be performed. It can be either state-estimation, with a value of "State", or parameter-estimation, with a value of "Parameters". The default choice is "State". - + + Example : ``{"EstimationOf":"Parameters"}`` + Alpha, Beta, Kappa, Reconditioner These keys are internal scaling parameters. "Alpha" requires a value between 1.e-4 and 1. "Beta" has an optimal value of 2 for Gaussian *a priori* @@ -119,12 +119,16 @@ The options of the algorithm are the following: obtained by setting it to 0. "Reconditioner" requires a value between 1.e-3 and 10, it defaults to 1. + Example : ``{"Alpha":1,"Beta":2,"Kappa":0,"Reconditioner":1}`` + StoreInternalVariables This Boolean key allows to store default internal variables, mainly the current state during iterative optimization process. Be careful, this can be a numerically costly choice in certain calculation cases. The default is "False". + Example : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations This list indicates the names of the supplementary variables that can be available at the end of the algorithm. It involves potentially costly @@ -132,6 +136,8 @@ The options of the algorithm are the following: these variables being calculated and stored by default. The possible names are in the following list: ["APosterioriCovariance", "BMA", "Innovation"]. + Example : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + See also ++++++++ diff --git a/doc/fr/ref_algorithm_3DVAR.rst b/doc/fr/ref_algorithm_3DVAR.rst index c59df09..b1d5da6 100644 --- a/doc/fr/ref_algorithm_3DVAR.rst +++ b/doc/fr/ref_algorithm_3DVAR.rst @@ -111,13 +111,17 @@ Les options de l'algorithme sont les suivantes: contraintes), "NCG" (minimisation de type gradient conjugué de Newton). Il est fortement conseillé de conserver la valeur par défaut. + Exemple : ``{"Minimizer":"LBFGSB"}`` + Bounds - Cette clé permet de définir des bornes supérieure et inférieure pour - chaque variable d'état optimisée. Les bornes doivent être données par une - liste de liste de paires de bornes inférieure/supérieure pour chaque - variable, avec une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les - bornes peuvent toujours être spécifiées, mais seuls les optimiseurs sous - contraintes les prennent en compte. + Cette clé permet de définir des bornes supérieure et inférieure pour chaque + variable d'état optimisée. Les bornes doivent être données par une liste de + liste de paires de bornes inférieure/supérieure pour chaque variable, avec + une valeur ``None`` chaque fois qu'il n'y a pas de borne. Les bornes peuvent + toujours être spécifiées, mais seuls les optimiseurs sous contraintes les + prennent en compte. + + Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` MaximumNumberOfSteps Cette clé indique le nombre maximum d'itérations possibles en optimisation @@ -127,12 +131,16 @@ Les options de l'algorithme sont les suivantes: de pas effectif d'arrêt peut être légèrement différent de la limite à cause d'exigences de contrôle interne de l'algorithme. + Exemple : ``{"MaximumNumberOfSteps":100}`` + CostDecrementTolerance Cette clé indique une valeur limite, conduisant à arrêter le processus itératif d'optimisation lorsque la fonction coût décroît moins que cette tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé de l'adapter aux besoins pour des problèmes réels. + Exemple : ``{"CostDecrementTolerance":1.e-7}`` + ProjectedGradientTolerance Cette clé indique une valeur limite, conduisant à arrêter le processus itératif d'optimisation lorsque toutes les composantes du gradient projeté @@ -141,25 +149,33 @@ Les options de l'algorithme sont les suivantes: interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé de le changer. + Exemple : ``{"ProjectedGradientTolerance":-1}`` + GradientNormTolerance Cette clé indique une valeur limite, conduisant à arrêter le processus itératif d'optimisation lorsque la norme du gradient est en dessous de cette limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le défaut est 1.e-5 et il n'est pas recommandé de le changer. + Exemple : ``{"GradientNormTolerance":1.e-5}`` + StoreInternalVariables Cette clé booléenne permet de stocker les variables internes par défaut, principalement l'état courant lors d'un processus itératif. Attention, cela peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des - calculs ou du stockage coûteux. La valeur par défaut est une liste vide, aucune de ces - variables n'étant calculée et stockée par défaut. Les noms possibles sont - dans la liste suivante : ["APosterioriCovariance", "BMA", "OMA", "OMB", - "Innovation", "SigmaObs2", "MahalanobisConsistency"]. + calculs ou du stockage coûteux. La valeur par défaut est une liste vide, + aucune de ces variables n'étant calculée et stockée par défaut. Les noms + possibles sont dans la liste suivante : ["APosterioriCovariance", "BMA", + "OMA", "OMB", "Innovation", "SigmaObs2", "MahalanobisConsistency"]. + + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_AdjointTest.rst b/doc/fr/ref_algorithm_AdjointTest.rst index 8b7b586..5bee55f 100644 --- a/doc/fr/ref_algorithm_AdjointTest.rst +++ b/doc/fr/ref_algorithm_AdjointTest.rst @@ -88,6 +88,8 @@ Les options de l'algorithme sont les suivantes: nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas de mise à l'échelle. + Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent Cette clé indique la valeur de l'exposant minimal du coefficient en puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur @@ -95,6 +97,8 @@ Les options de l'algorithme sont les suivantes: -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. + Exemple : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection Cette clé indique la direction vectorielle utilisée pour la dérivée directionnelle autour du point nominal de vérification. Cela doit être un @@ -102,12 +106,16 @@ Les options de l'algorithme sont les suivantes: perturbation par défaut autour de zéro de la même taille vectorielle que le point de vérification. + Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + SetSeed Cette clé permet de donner un nombre entier pour fixer la graine du générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle utilise ainsi l'initialisation par défaut de l'ordinateur. + Exemple : ``{"SetSeed":1000}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_Blue.rst b/doc/fr/ref_algorithm_Blue.rst index 30391fe..37e4ee7 100644 --- a/doc/fr/ref_algorithm_Blue.rst +++ b/doc/fr/ref_algorithm_Blue.rst @@ -107,6 +107,8 @@ Les options de l'algorithme sont les suivantes: peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -116,6 +118,8 @@ Les options de l'algorithme sont les suivantes: "OMA", "OMB", "Innovation", "SigmaBck2", "SigmaObs2", "MahalanobisConsistency"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_EnsembleBlue.rst b/doc/fr/ref_algorithm_EnsembleBlue.rst index 282b017..8e8246d 100644 --- a/doc/fr/ref_algorithm_EnsembleBlue.rst +++ b/doc/fr/ref_algorithm_EnsembleBlue.rst @@ -100,7 +100,9 @@ Les options de l'algorithme sont les suivantes: Cette clé permet de donner un nombre entier pour fixer la graine du générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle - utilise ainsi l'initialisation de l'ordinateur. + utilise ainsi l'initialisation par défaut de l'ordinateur. + + Exemple : ``{"SetSeed":1000}`` Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ExtendedBlue.rst b/doc/fr/ref_algorithm_ExtendedBlue.rst index 445126c..7d7dc50 100644 --- a/doc/fr/ref_algorithm_ExtendedBlue.rst +++ b/doc/fr/ref_algorithm_ExtendedBlue.rst @@ -104,6 +104,8 @@ Les options de l'algorithme sont les suivantes: peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -113,6 +115,8 @@ Les options de l'algorithme sont les suivantes: "OMA", "OMB", "Innovation", "SigmaBck2", "SigmaObs2", "MahalanobisConsistency"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst index 6a1c738..61233c5 100644 --- a/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_ExtendedKalmanFilter.rst @@ -101,21 +101,23 @@ Les options de l'algorithme sont les suivantes: une valeur extrême chaque fois qu'il n'y a pas de borne (``None`` n'est pas une valeur autorisée lorsqu'il n'y a pas de borne). - ConstrainedBy - Cette clé permet de définir la méthode pour prendre en compte les bornes. Les - méthodes possibles sont dans la liste suivante : ["EstimateProjection"]. + Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,1.e99],[-1.e99,1.e99]]}`` EstimationOf Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être soit une estimation de l'état, avec la valeur "State", ou une estimation de paramètres, avec la valeur "Parameters". Le choix par défaut est "State". + Exemple : ``{"EstimationOf":"Parameters"}`` + StoreInternalVariables Cette clé booléenne permet de stocker les variables internes par défaut, principalement l'état courant lors d'un processus itératif. Attention, cela peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -124,6 +126,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["APosterioriCovariance", "BMA", "Innovation"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_FunctionTest.rst b/doc/fr/ref_algorithm_FunctionTest.rst index 0e838f2..7827476 100644 --- a/doc/fr/ref_algorithm_FunctionTest.rst +++ b/doc/fr/ref_algorithm_FunctionTest.rst @@ -84,15 +84,21 @@ Les options de l'algorithme sont les suivantes: Cette clé indique le nombre de décimales de précision pour les affichages de valeurs réelles. La valeur par défaut est 5, avec un minimum de 0. + Exemple : ``{"NumberOfPrintedDigits":5}`` + NumberOfRepetition Cette clé indique le nombre de fois où répéter l'évaluation de la fonction. La valeur par défaut est 1. - + + Exemple : ``{"NumberOfRepetition":3}`` + SetDebug Cette clé requiert l'activation, ou pas, du mode de débogage durant l'évaluation de la fonction. La valeur par défaut est "True", les choix sont "True" ou "False". + Exemple : ``{"SetDebug":False}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_GradientTest.rst b/doc/fr/ref_algorithm_GradientTest.rst index a353da0..747f9b3 100644 --- a/doc/fr/ref_algorithm_GradientTest.rst +++ b/doc/fr/ref_algorithm_GradientTest.rst @@ -110,6 +110,8 @@ Les options de l'algorithme sont les suivantes: nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas de mise à l'échelle. + Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent Cette clé indique la valeur de l'exposant minimal du coefficient en puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur @@ -117,6 +119,8 @@ Les options de l'algorithme sont les suivantes: -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. + Exemple : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection Cette clé indique la direction vectorielle utilisée pour la dérivée directionnelle autour du point nominal de vérification. Cela doit être un @@ -124,6 +128,8 @@ Les options de l'algorithme sont les suivantes: perturbation par défaut autour de zéro de la même taille vectorielle que le point de vérification. + Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + ResiduFormula Cette clé indique la formule de résidu qui doit être utilisée pour le test. Le choix par défaut est "Taylor", et les choix possibles sont "Taylor" @@ -131,13 +137,17 @@ Les options de l'algorithme sont les suivantes: le carré de la perturbation) et "Norm" (résidu obtenu en prenant la norme du développement de Taylor à l'ordre 0, qui approxime le gradient, et qui doit rester constant). - + + Exemple : ``{"ResiduFormula":"Taylor"}`` + SetSeed Cette clé permet de donner un nombre entier pour fixer la graine du générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle utilise ainsi l'initialisation par défaut de l'ordinateur. + Exemple : ``{"SetSeed":1000}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_KalmanFilter.rst b/doc/fr/ref_algorithm_KalmanFilter.rst index f12940e..aa427f5 100644 --- a/doc/fr/ref_algorithm_KalmanFilter.rst +++ b/doc/fr/ref_algorithm_KalmanFilter.rst @@ -105,12 +105,16 @@ Les options de l'algorithme sont les suivantes: soit une estimation de l'état, avec la valeur "State", ou une estimation de paramètres, avec la valeur "Parameters". Le choix par défaut est "State". + Exemple : ``{"EstimationOf":"Parameters"}`` + StoreInternalVariables Cette clé booléenne permet de stocker les variables internes par défaut, principalement l'état courant lors d'un processus itératif. Attention, cela peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -119,6 +123,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["APosterioriCovariance", "BMA", "Innovation"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_LinearLeastSquares.rst b/doc/fr/ref_algorithm_LinearLeastSquares.rst index ed507fa..36e36fc 100644 --- a/doc/fr/ref_algorithm_LinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_LinearLeastSquares.rst @@ -95,6 +95,8 @@ Les options de l'algorithme sont les suivantes: peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -102,6 +104,8 @@ Les options de l'algorithme sont les suivantes: aucune de ces variables n'étant calculée et stockée par défaut. Les noms possibles sont dans la liste suivante : ["OMA"]. + Exemple : ``{"StoreSupplementaryCalculations":["OMA"]}`` + *Astuce pour cet algorithme :* Comme les commandes *"Background"* et *"BackgroundError"* sont requises pour diff --git a/doc/fr/ref_algorithm_LinearityTest.rst b/doc/fr/ref_algorithm_LinearityTest.rst index e18cb23..f3b3c4b 100644 --- a/doc/fr/ref_algorithm_LinearityTest.rst +++ b/doc/fr/ref_algorithm_LinearityTest.rst @@ -154,6 +154,8 @@ Les options de l'algorithme sont les suivantes: nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas de mise à l'échelle. + Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent Cette clé indique la valeur de l'exposant minimal du coefficient en puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur @@ -161,6 +163,8 @@ Les options de l'algorithme sont les suivantes: -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. + Exemple : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection Cette clé indique la direction vectorielle utilisée pour la dérivée directionnelle autour du point nominal de vérification. Cela doit être un @@ -168,6 +172,8 @@ Les options de l'algorithme sont les suivantes: perturbation par défaut autour de zéro de la même taille vectorielle que le point de vérification. + Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + ResiduFormula Cette clé indique la formule de résidu qui doit être utilisée pour le test. Le choix par défaut est "CenteredDL", et les choix possibles sont @@ -181,12 +187,16 @@ Les options de l'algorithme sont les suivantes: normalisé par l'écart quadratique moyen (RMS) au point nominal, qui doit rester proche de 0). + Exemple : ``{"ResiduFormula":"CenteredDL"}`` + SetSeed Cette clé permet de donner un nombre entier pour fixer la graine du générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle utilise ainsi l'initialisation par défaut de l'ordinateur. + Exemple : ``{"SetSeed":1000}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst index 43d8716..8723db7 100644 --- a/doc/fr/ref_algorithm_NonLinearLeastSquares.rst +++ b/doc/fr/ref_algorithm_NonLinearLeastSquares.rst @@ -109,6 +109,8 @@ Les options de l'algorithme sont les suivantes: (minimisation non linéaire de type Levenberg-Marquard). Il est fortement conseillé de conserver la valeur par défaut. + Exemple : ``{"Minimizer":"LBFGSB"}`` + Bounds Cette clé permet de définir des bornes supérieure et inférieure pour chaque variable d'état optimisée. Les bornes doivent être données par une @@ -117,6 +119,8 @@ Les options de l'algorithme sont les suivantes: bornes peuvent toujours être spécifiées, mais seuls les optimiseurs sous contraintes les prennent en compte. + Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,None],[None,None]]}`` + MaximumNumberOfSteps Cette clé indique le nombre maximum d'itérations possibles en optimisation itérative. Le défaut est 15000, qui est très similaire à une absence de @@ -125,12 +129,16 @@ Les options de l'algorithme sont les suivantes: de pas effectif d'arrêt peut être légèrement différent de la limite à cause d'exigences de contrôle interne de l'algorithme. + Exemple : ``{"MaximumNumberOfSteps":100}`` + CostDecrementTolerance Cette clé indique une valeur limite, conduisant à arrêter le processus itératif d'optimisation lorsque la fonction coût décroît moins que cette tolérance au dernier pas. Le défaut est de 1.e-7, et il est recommandé de l'adapter aux besoins pour des problèmes réels. + Exemple : ``{"CostDecrementTolerance":1.e-7}`` + ProjectedGradientTolerance Cette clé indique une valeur limite, conduisant à arrêter le processus itératif d'optimisation lorsque toutes les composantes du gradient projeté @@ -139,18 +147,24 @@ Les options de l'algorithme sont les suivantes: interne de chaque optimiseur (usuellement 1.e-5), et il n'est pas recommandé de le changer. + Exemple : ``{"ProjectedGradientTolerance":-1}`` + GradientNormTolerance Cette clé indique une valeur limite, conduisant à arrêter le processus itératif d'optimisation lorsque la norme du gradient est en dessous de cette limite. C'est utilisé uniquement par les optimiseurs sans contraintes. Le défaut est 1.e-5 et il n'est pas recommandé de le changer. + Exemple : ``{"GradientNormTolerance":1.e-5}`` + StoreInternalVariables Cette clé booléenne permet de stocker les variables internes par défaut, principalement l'état courant lors d'un processus itératif. Attention, cela peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -159,6 +173,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["APosterioriCovariance", "BMA", "OMA", "OMB", "Innovation", "SigmaObs2", "MahalanobisConsistency"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + *Astuce pour cet algorithme :* Comme la commande *"BackgroundError"* est requise pour TOUS les algorithmes diff --git a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst index b0ad010..8bb61bb 100644 --- a/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst +++ b/doc/fr/ref_algorithm_ParticleSwarmOptimization.rst @@ -106,19 +106,27 @@ Les options de l'algorithme sont les suivantes: itérative. Le défaut est 50, qui est une limite arbitraire. Il est ainsi recommandé d'adapter ce paramètre aux besoins pour des problèmes réels. + Exemple : ``{"MaximumNumberOfSteps":100}`` + NumberOfInsects Cette clé indique le nombre d'insectes ou de particules dans l'essaim. La valeur par défaut est 100, qui est une valeur par défaut usuelle pour cet algorithme. + Exemple : ``{"NumberOfInsects":100}`` + SwarmVelocity Cette clé indique la part de la vitesse d'insecte qui est imposée par l'essaim. C'est une valeur réelle positive. Le défaut est de 1. + Exemple : ``{"SwarmVelocity":1.}`` + GroupRecallRate Cette clé indique le taux de rappel vers le meilleur insecte de l'essaim. C'est une valeur réelle comprise entre 0 et 1. Le défaut est de 0.5. + Exemple : ``{"GroupRecallRate":0.5}`` + QualityCriterion Cette clé indique le critère de qualité, qui est minimisé pour trouver l'estimation optimale de l'état. Le défaut est le critère usuel de @@ -126,7 +134,9 @@ Les options de l'algorithme sont les suivantes: pondérés augmentés. Les critères possibles sont dans la liste suivante, dans laquelle les noms équivalents sont indiqués par un signe "=" : ["AugmentedWeightedLeastSquares"="AWLS"="DA", "WeightedLeastSquares"="WLS", - "LeastSquares"="LS"="L2", "AbsoluteValue"="L1", "MaximumError"="ME"] + "LeastSquares"="LS"="L2", "AbsoluteValue"="L1", "MaximumError"="ME"]. + + Exemple : ``{"QualityCriterion":"DA"}`` BoxBounds Cette clé permet de définir des bornes supérieure et inférieure pour chaque @@ -137,18 +147,24 @@ Les options de l'algorithme sont les suivantes: valeur autorisée lorsqu'il n'y a pas de borne). Cette clé est requise et il n'y a pas de valeurs par défaut. + Exemple : ``{"BoxBounds":[[-0.5,0.5],[0.01,2.],[0.,1.e99],[-1.e99,1.e99]]}`` + SetSeed Cette clé permet de donner un nombre entier pour fixer la graine du générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle utilise ainsi l'initialisation par défaut de l'ordinateur. + Exemple : ``{"SetSeed":1000}`` + StoreInternalVariables Cette clé booléenne permet de stocker les variables internes par défaut, principalement l'état courant lors d'un processus itératif. Attention, cela peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -156,6 +172,8 @@ Les options de l'algorithme sont les suivantes: aucune de ces variables n'étant calculée et stockée par défaut. Les noms possibles sont dans la liste suivante : ["BMA", "OMA", "OMB", "Innovation"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_QuantileRegression.rst b/doc/fr/ref_algorithm_QuantileRegression.rst index 3ef9f27..25027cc 100644 --- a/doc/fr/ref_algorithm_QuantileRegression.rst +++ b/doc/fr/ref_algorithm_QuantileRegression.rst @@ -86,24 +86,32 @@ Les options de l'algorithme sont les suivantes: Cette clé permet de définir la valeur réelle du quantile recherché, entre 0 et 1. La valeur par défaut est 0.5, correspondant à la médiane. + Exemple : ``{"Quantile":0.5}`` + MaximumNumberOfSteps Cette clé indique le nombre maximum d'itérations possibles en optimisation itérative. Le défaut est 15000, qui est très similaire à une absence de limite sur les itérations. Il est ainsi recommandé d'adapter ce paramètre aux besoins pour des problèmes réels. + Exemple : ``{"MaximumNumberOfSteps":100}`` + CostDecrementTolerance Cette clé indique une valeur limite, conduisant à arrêter le processus itératif d'optimisation lorsque la fonction coût décroît moins que cette tolérance au dernier pas. Le défaut est de 1.e-6, et il est recommandé de l'adapter aux besoins pour des problèmes réels. + Exemple : ``{"CostDecrementTolerance":1.e-7}`` + StoreInternalVariables Cette clé booléenne permet de stocker les variables internes par défaut, principalement l'état courant lors d'un processus itératif. Attention, cela peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -111,6 +119,8 @@ Les options de l'algorithme sont les suivantes: aucune de ces variables n'étant calculée et stockée par défaut. Les noms possibles sont dans la liste suivante : ["BMA", "OMA", "OMB", "Innovation"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + *Astuce pour cet algorithme :* Comme les commandes *"BackgroundError"* et *"ObservationError"* sont diff --git a/doc/fr/ref_algorithm_SamplingTest.rst b/doc/fr/ref_algorithm_SamplingTest.rst index 6485a2b..cac78f6 100644 --- a/doc/fr/ref_algorithm_SamplingTest.rst +++ b/doc/fr/ref_algorithm_SamplingTest.rst @@ -105,23 +105,31 @@ Les options de l'algorithme sont les suivantes: Cette clé décrit les points de calcul sous la forme d'une liste de n-uplets, chaque n-uplet étant un état. + 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 + SampleAsExplicitHyperCube Cette clé décrit les points de calcul sous la forme d'un hyper-cube, dont on donne la liste des échantillonages de chaque variable comme une liste. C'est donc une liste de listes, chacune étant de taille potentiellement différente. + Exemple : ``{"SampleAsExplicitHyperCube":[[0.,0.25,0.5,0.75,1.],[-2,2,1]]}`` pour un espace d'état à 2 dimensions + SampleAsMinMaxStepHyperCube Cette clé décrit les points de calcul sous la forme d'un hyper-cube dont on donne la liste des échantillonages de chaque variable par un triplet *[min,max,step]*. C'est donc une liste de la même taille que celle de - l'état. + l'état. Les bornes sont incluses. + + Exemple : ``{"SampleAsMinMaxStepHyperCube":[[0.,1.,0.25],[-1,3,1]]}`` pour un espace d'état à 2 dimensions SetDebug Cette clé requiert l'activation, ou pas, du mode de débogage durant l'évaluation de la fonction. La valeur par défaut est "True", les choix sont "True" ou "False". + Exemple : ``{"SetDebug":False}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -130,6 +138,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["CostFunctionJ", "CurrentState", "Innovation", "ObservedState"]. + Exemple : ``{"StoreSupplementaryCalculations":["CostFunctionJ", "ObservedState"]}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_TangentTest.rst b/doc/fr/ref_algorithm_TangentTest.rst index 5a5c3ef..d665d1f 100644 --- a/doc/fr/ref_algorithm_TangentTest.rst +++ b/doc/fr/ref_algorithm_TangentTest.rst @@ -98,6 +98,8 @@ Les options de l'algorithme sont les suivantes: nominal de vérification. La valeur par défaut est de 1, ce qui signifie pas de mise à l'échelle. + Exemple : ``{"AmplitudeOfInitialDirection":0.5}`` + EpsilonMinimumExponent Cette clé indique la valeur de l'exposant minimal du coefficient en puissance de 10 qui doit être utilisé pour faire décroître le multiplicateur @@ -105,6 +107,8 @@ Les options de l'algorithme sont les suivantes: -20. Par exemple, la valeur par défaut conduit à calculer le résidu de la formule avec un incrément fixe multiplié par 1.e0 jusqu'à 1.e-8. + Exemple : ``{"EpsilonMinimumExponent":-12}`` + InitialDirection Cette clé indique la direction vectorielle utilisée pour la dérivée directionnelle autour du point nominal de vérification. Cela doit être un @@ -112,12 +116,16 @@ Les options de l'algorithme sont les suivantes: perturbation par défaut autour de zéro de la même taille vectorielle que le point de vérification. + Exemple : ``{"InitialDirection":[0.1,0.1,100.,3}`` + SetSeed Cette clé permet de donner un nombre entier pour fixer la graine du générateur aléatoire utilisé pour générer l'ensemble. Un valeur pratique est par exemple 1000. Par défaut, la graine est laissée non initialisée, et elle utilise ainsi l'initialisation par défaut de l'ordinateur. + Exemple : ``{"SetSeed":1000}`` + Voir aussi ++++++++++ diff --git a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst index 4dd6c53..b9b08ac 100644 --- a/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst +++ b/doc/fr/ref_algorithm_UnscentedKalmanFilter.rst @@ -106,15 +106,15 @@ Les options de l'algorithme sont les suivantes: une valeur extrême chaque fois qu'il n'y a pas de borne (``None`` n'est pas une valeur autorisée lorsqu'il n'y a pas de borne). - ConstrainedBy - Cette clé permet de définir la méthode pour prendre en compte les bornes. Les - méthodes possibles sont dans la liste suivante : ["EstimateProjection"]. + Exemple : ``{"Bounds":[[2.,5.],[1.e-2,10.],[-30.,1.e99],[-1.e99,1.e99]]}`` EstimationOf Cette clé permet de choisir le type d'estimation à réaliser. Cela peut être soit une estimation de l'état, avec la valeur "State", ou une estimation de paramètres, avec la valeur "Parameters". Le choix par défaut est "State". + Exemple : ``{"EstimationOf":"Parameters"}`` + Alpha, Beta, Kappa, Reconditioner Ces clés sont des paramètres de mise à l'échelle interne. "Alpha" requiert une valeur comprise entre 1.e-4 et 1. "Beta" a une valeur optimale de 2 pour @@ -123,12 +123,16 @@ Les options de l'algorithme sont les suivantes: "Reconditioner" requiert une valeur comprise entre 1.e-3 et 10, son défaut étant 1. + Exemple : ``{"Alpha":1,"Beta":2,"Kappa":0,"Reconditioner":1}`` + StoreInternalVariables Cette clé booléenne permet de stocker les variables internes par défaut, principalement l'état courant lors d'un processus itératif. Attention, cela peut être un choix numériquement coûteux dans certains cas de calculs. La valeur par défaut est "False". + Exemple : ``{"StoreInternalVariables":True}`` + StoreSupplementaryCalculations Cette liste indique les noms des variables supplémentaires qui peuvent être disponibles à la fin de l'algorithme. Cela implique potentiellement des @@ -137,6 +141,8 @@ Les options de l'algorithme sont les suivantes: possibles sont dans la liste suivante : ["APosterioriCovariance", "BMA", "Innovation"]. + Exemple : ``{"StoreSupplementaryCalculations":["BMA","Innovation"]}`` + Voir aussi ++++++++++ -- 2.39.2