# Valeur calculée de la variable

## Variable avec une valeur par défaut calculée

Créons une variable dont la valeur est retournée par la fonction "return_no" :

```xml
<variables>
  <variable name="my_calculated_variable"/>
</variables>
<constraints>
  <fill name="return_no">
    <target>my_calculated_variable</target>
  </fill>
</constraints>
```

En YAML :

```yml
variables:
- variable:
    name: my_calculated_variable
constraints:
- fill:
  - name: return_no
    target:
    - text: my_calculated_variable
```

Puis créons la fonction "return_no" :

```python
def return_no():
    return 'no'
```

La [cible (de type variable)](../target/variable.md) du calcul est ici "my_calculated_variable".

Dans ce cas, la valeur par défaut est la valeur retournée par la fonction (ici "no"), elle sera calculée tant que l'utilisateur n'a pas de spécifié de valeur à cette variable.

Attention, si une valeur par défaut est définit dans la variable "my_calculated_variable" :

```xml
<variable name="my_calculated_variable">
  <value>yes</value>
</variable>
```

En YAML :

```yml
variables:
- variable:
    name: my_calculated_variable
    value:
    - text: yes
```

Cette valeur par défaut sera complètement ignorée. C'est le calcul qui en définira la valeur.

Il est possible de définir des [paramètres](../param/README.md) à cette fonction.

## Variable avec une valeur calculée

En ajoutant le paramètre "hidden" à "True" dans la variable précédente, l'utilisateur n'aura plus la possibilité de modifié la valeur. La valeur de la variable sera donc systématiquement calculée :

```xml
<variable name="my_calculated_variable" hidden="True"/>
```

En YAML :

```yml
variables:
- variable:
    name: my_calculated_variable
    hidden: true
```

Si une condition "hidden_if_in" est spécifié à la variable, la valeur sera modifiable par l'utilisateur si elle n'est pas cachée mais elle sera systèmatiquement calculée (même si elle a déjà était modifiée) si la variable est cachée.

## Variable meneuse ou suiveuse avec valeur calculé

Une [variable suiveuse](../family/leadership.md) ne peut pas être calculé automatiquement.
Une [variable meneuse](../family/leadership.md) peut être calculé automatiquement.
Si la variable n'est pas multiple, il ne faut pas que le calcule retourne une liste.

## Variable dynamique avec une valeur calculée

Il est également possible de calculer [une variable d'une famille dynamique](../family/auto.md) à partir d'une variable standard :

```xml
<variables>
  <variable name='suffixes' type='string' description="Suffixes of dynamic family" multi="True">
    <value>val1</value>
    <value>val2</value>
  </variable>
  <variable name="my_variable" type="string" description="My variable">
    <value>val</value>
  </variable>
  <family name='dyn' dynamic="suffixes">
    <variable name="my_calculated_variable_dyn_" type="string" description="My calculated variable"/>
      <value>val</value>
    </variable>
  </family>
</variables>
<constraints>
  <fill name="return_value">
    <param type="variable">my_variable</param>
    <target>my_calculated_variable_dyn_</target>
  </fill>
</constraints>
```

En YAML :

```yml
variables:
- variable:
    name: suffixes
    type: string
    description: Suffixes of dynamic family
    multi: true
    value:
    - text: val1
    - text: val2
- variable:
    name: my_variable
    type: string
    description: My variable
    value:
    - text: val
- family:
    name: dyn
    dynamic: suffixes
    variables:
    - variable:
        name: my_calculated_variable_dyn_
        type: string
        description: My calculated variable
        value:
        - text: val
constraints:
- fill:
  - name: return_value
    param:
    - type: variable
      text: my_variable
    target:
    - text: my_calculated_variable_dyn_
```

Dans ce cas, les variables dynamiques "my_calculated_variable_dyn_" seront calculés à partir de la valeur de la variable "my_variable".
Que cela soit pour la variable "my_calculated_variable_dyn_val1" et "my_calculated_variable_dyn_val2".

Par contre, il n'est pas possible de faire un calcul pour une seule des deux variables issues de la variable dynamique.
Si c'est ce que vous cherchez à faire, il faudra prévoir un traitement particulier dans votre fonction.

Dans ce cas, il faut explicitement demander la valeur du suffix dans la fonction :

```xml
<constraints>
  <fill name="return_value_suffix">
    <param type="variable">my_variable</param>
    <param type="suffix"/>
    <target>my_calculated_variable_dyn_</target>
  </fill>
</constraints>
```

En YAML :

```yml
constraints:
- fill:
  - name: return_value_suffix
    param:
    - type: variable
      text: my_variable
    - type:suffix
    target:
    - text: my_calculated_variable_dyn_
```

Et ainsi faire un traitement spécifique pour ce suffix :

```python
def return_value_suffix(value, suffix):
    if suffix == 'val1':
        return value
```

## Variable avec valeur calculée obligatoire

Par défaut les variables calculées ne sont pas des variables obligatoires.
Dans ce cas un calcul peut retourner "None" ou "", mais surtout un utilisateur peut spécifier une valeur nulle à cette variable. Dans ce cas le calcul ne sera plus réalisé.