Exemples d’utilisation
======================

Pour différents exemples on se reportera au cas test ZZZZ100A.


Une formule s'utilise comme une fonction tabulée
------------------------------------------------

Définition de la formule Sia:

SIa = FORMULE(NOM_PARA='X',VALE='sin(X)')

Fonction tabulée équivalente SI:

LR = DEFI_LIST_REEL( DEBUT = 0.,

INTERVALLE = _F( JUSQU_A = pi , PAS = 0.01 )

SI = CALC_FONC_INTERP( FONCTION = SIa,

LIST_PARA = LR,

NOM_PARA = 'X',

NOM_RESU = 'DEPL', )

Pour définir ainsi une fonction tabulée à partir d’une formule interprétable, voir CALC_FONC_INTERP [:external:ref:`U4.32.01 <U4.32.01>`].

Usage de SI ou de SIa dans un mot clé simple attendant une fonction ou une formule:

champ=CREA_CHAMP( ... AFFE = _F( ... VALE_F = SI ou SIa, ) )


Une formule peut être évaluée comme un réel
-------------------------------------------

Dans le corps du fichier de commande:

SIa = FORMULE(NOM_PARA='X',VALE='sin(X)')

X = SIa(1.57)

print SIa(1.57)

Derrière un mot clé simple attendant un réel :

LR = DEFI_LIST_REEL(DEBUT=SIa(0.),

.. code-block:: text

    INTERVALLE=_F(JUSQU_A=SIa(pi/2.), PAS=0.01))

Dans une autre formule:

SIb = FORMULE(NOM_PARA='X', VALE='X*SIa(5.)', SIa=SIa)


Invoquer une formule ou une fonction dans une autre formule
-----------------------------------------------------------

SIa = FORMULE(NOM_PARA='X',VALE='sin(X)')

Attention à penser à mettre l’argument (X ici) dans l’appel à la fonction SIa :

SIb = FORMULE(NOM_PARA='X', VALE='X*SIa(X)', SIa=SIa)


Formule à plusieurs paramètres
------------------------------

NAP = FORMULE(NOM_PARA=('AMOR','FREQ'),

VALE='''(1./((2.*pi*FREQ)**2 - OMEGA**2 )**2

+(2.*AMOR*2.*pi*FREQ*OMEGA)**2)''',

OMEGA=OMEGA)

Dans cet exemple, on définit une formule à 2 paramètres. Compte tenu de la longueur de l’expression, elle est écrite pour plus de commodité sur plusieurs lignes avec des triples quotes pour la délimiter. La constante pi est une constante standard (cf paragraphe [:ref:`§3.2 <§3.2>`]), la constante OMEGAdoit être fournie explicitement.

Dans l’état actuel, seules les formules de :math:`\mathrm{ℝ}` dans :math:`\mathrm{ℝ}` ou :math:`\mathrm{ℂ}` sont possibles: un seul scalaire produit.


Formule issue de programmation d’une fonction Python
----------------------------------------------------

On peut faire référence dans une formule à des fonctions programmées en Python, ce qui autorise des formules beaucoup plus complexes que de simples expressions algébriques.

Par exemple une fonction de Heaviside:

:math:`\mathrm{HEAVYSIDE}(x)=\lbrace \begin{array}{c}0.\mathrm{si}x<0.\\ 1.\mathrm{si}x\ge 0.\end{array}`

La fonction Python se programme ainsi:

def heaviside(x):

if x < 0.:

return 0.

else:

return 1.

F_HVS = FORMULE(NOM_PARA='INST',

VALE='heaviside(INST)',

heaviside=heaviside)

**Attention:**

*L’usage de programmation Python dans le fichier de commandes (ici la méthode* heaviside *) est incompatible avec l’édition de ce fichier* en mode graphique *avec* AsterStudy.

Pour que la formule F_HVS puisse être évaluée en POURSUITE, il faut redéfinir la fonction de Heaviside et la déclarer à la formule:

def heaviside(x):

if x < 0.:

return 0.

else:

return 1.

F_HVS.setContext( dict(heaviside=heaviside) )


Exemple de définition de formules dans une boucle Python
--------------------------------------------------------

Quand on définit, dans une boucle, des formules dont l'expression dépend de l'indice de la boucle, on voit tout l'intérêt de passer explicitement les constantes.

Exemple:

for i in range(3):

FO[i] = FORMULE(VALE='cos(i*INST)', NOM_PARA='INST', i=i)

CH[i] = CREA_CHAMP(OPERATION='AFFE', ..., VALE_F=FO[i])

Avec ces instructions, on a défini 3 formules qui ont toutes la même expression.

À chaque itération, une valeur différente est stockée pour l'argument i. Quand la formule est évaluée pour ensuite affecter les valeurs du champ, il n'y a pas d’ambiguïté sur la valeur de i. C'est la valeur attachée à la formule lors de sa création, et non pas la valeur actuelle de i.

En effet, en mode PAR_LOT='OUI', toutes les commandes sont crées, et ensuite seulement, exécutées. Dans ce mode, i vaut 2 lors de l'exécution proprement dite des commandes.