u4.92.02 Procédure TEST_FONCTION#

Syntaxe#

Détail de la syntaxe
TEST_FONCTION(
    ◇ VALEUR = _F(
         ◆ FONCTION = formule / fonction_c / fonction / nappe,
         ◇ NOM_PARA = text,
         ◆ / VALE_PARA = float,
           / INTERVALLE = float,
         # Si: True
             ◆ / VALE_CALC_C = complex,
               / VALE_CALC = float,
             ◇ VALE_ABS = / "OUI",
                          / "NON" (par défaut),
             ◇ TYPE_TEST = / "SOMM_ABS",
                           / "SOMM",
                           / "MAX",
                           / "MIN",
             ◇ TOLE_MACHINE = float (défaut: 1e-06),
             ◇ CRITERE = / "RELATIF" (par défaut),
                         / "ABSOLU",
             # Si: exists("REFERENCE")
                 ◆ / VALE_REFE_C = complex,
                   / VALE_REFE = float,
                 ◇ PRECISION = float (défaut: 0.001),
             ◇ REFERENCE = / "ANALYTIQUE",
                           / "SOURCE_EXTERNE",
                           / "AUTRE_ASTER",
                           / "NON_DEFINI",
             # Si: exists("VALE_CALC") and abs(VALE_CALC if type(VALE_CALC) not in (list, tuple) else VALE_CALC[0]) < 1.e-16
                 ◇ ORDRE_GRANDEUR = float,
             ◇ LEGENDE = text,
      ),
    ◇ ATTRIBUT = _F(
         ◆ FONCTION = formule / fonction_c / fonction / nappe,
         ◇ PARA = float,
         ◇ CRIT_PARA = / "RELATIF" (par défaut),
                       / "ABSOLU",
         ◇ PREC_PARA = float (défaut: 0.001),
         ◆ ATTR = / "NOM_PARA",
                  / "NOM_RESU",
                  / "PROL_DROITE",
                  / "PROL_GAUCHE",
                  / "INTERPOL",
                  / "PROL_GAUCHE_FONC",
                  / "PROL_DROITE_FONC",
                  / "INTERPOL_FONC",
                  / "NOM_PARA_FONC",
         ◆ ATTR_REFE = text,
         ◇ REFERENCE = / "ANALYTIQUE",
                       / "SOURCE_EXTERNE",
                       / "AUTRE_ASTER",
      ),
)


◆ : obligatoire
◇ : optionnel
⟐ : présent par défaut
& : ensemble
/ : un seul parmi
| : plusieurs choix possibles

Opérandes#

Mot clé VALEUR#

♦    VALEUR =

Mot clé facteur pour tester une valeur d’une fonction ou d’une nappe.

Opérande FONCTION#

♦    FONCTION = f

Nom de la fonction (à un paramètre) ou de la nappe (à deux paramètres) sur laquelle s’effectue l’opération.

Opérande NOM_PARA#

◊    NOM_PARA = lnom

Dans le cas d’une fonction, ce mot clé est non traité.

Dans le cas d’une nappe, l’utilisateur donnera 2 noms de paramètre : le premier définissant le paramètre de la nappe, le deuxième définissant le paramètre de la fonction que l’on veut tester (voir la commande DEFI_NAPPE [U4.31.03]).

Opérande VALE_PARA#

♦    VALE_PARA = lpara

Dans le cas d’une fonction, l’utilisateur donne la valeur du paramètre pour laquelle la valeur de la fonction est testée.

Dans le cas d’une nappe, l’utilisateur donne les 2 valeurs correspondant aux noms des deux paramètres (celui de la nappe et celui de la fonction).

Mots-clés communs aux commandes TEST_XXX#

La définition des valeurs de non régression et de référence, ainsi que des tolérances admissibles, les critère de comparaison est détaillée dans la documentation [u4.92.01] de la commande TEST_RESU.

Les spécificités de TEST_FONCTION sont:

  • pas de valeurs entières ou chaînes de caractères,

  • pas de tolérance sur la valeur du paramètre (TOLE_MACHINE et CRITERE ne prenne qu’une seule valeur).

Mot clé ATTRIBUT#

/    ATTRIBUT=

Mot clé facteur pour tester un attribut d’une fonction ou d’une nappe.

Opérande FONCTION#

♦    FONCTION = f

Nom de la fonction ou de la nappe sur laquelle s’effectue l’opération.

Opérande PARA#

◊    PARA = reel

Dans le cas d’une fonction, ce mot clé n’est pas nécessaire.

Dans le cas d’une nappe, l’utilisateur donne la valeur du paramètre pour récupérer la fonction afin de tester l’attribut.

Opérandes PREC_PARA / CRIT_PARA#

◊    PREC_PARA = prec

On recherche la fonction définie par la valeur du paramètre dans un intervalle défini par la position absolue ou relative :

« inst ± prec » (confer CRITERE[§3.2.3]).

Par défaut prec = 1.0D-3.

◊    CRIT_PARA =

“RELATIF” : l’intervalle de recherche est : [inst(1-prec),inst(1+prec)]

“ABSOLU” : l’intervalle de recherche est : [inst-prec,inst+prec]

Opérande ATTR#

♦    ATTR =

Nom de l’attribut à tester. Pour la signification des attributs se reporter à DEFI_FONCTION [U4.31.02] ou à DEFI_NAPPE [U4.31.03].

Opérande ATTR_REFE#

♦    ATTR_REFE = attr

Attribut de référence. Pour la signification des attributs se reporter à DEFI_FONCTION [U4.31.02] ou à DEFI_NAPPE [U4.31.03].

Exemples#

Vérification d’une nappe#

df1 = DEFI_FONCTION ( NOM_PARA = “INST”, NOM_RESU = “DEPL”, VALE = (0.,0.,1.,1.,2.,2.,3.,3.,4.,4. ) ) df2 = DEFI_FONCTION ( NOM_PARA = “INST”, NOM_RESU = “DEPL”, VALE = (3., 3., 4., 4., 5., 5. ) ) dn1 = DEFI_NAPPE ( NOM_PARA = “AMOR”, NOM_RESU = “DEPL”, VALE = (0.01, 0.02), FONCTION = ( df1, df2 ))

TEST_FONCTION (

# on vérifie l’attribut “NOM_PARA” de la fonction df1 dans la nappe dn1

ATTRIBUT = ( _F(    FONCTION =    dn1    ,

PARA = 0.01, # 0.01 atteint df1 ATTR = “NOM_PARA_FONC”, ATTR_REFE = “INST” ),

# on vérifie l’attribut “NOM_PARA” de la nappe dn1

_F(    FONCTION =    dn1    ,

ATTR = “NOM_PARA”, ATTR_REFE = “AMOR” )),

# on vérifie une valeur de la nappe dn1 (en pratique sur la fonction df1)

VALEUR =    _F(    FONCTION =    dn1,

NOM_PARA = (“AMOR”, “INST” ), VALE_PARA = ( 0.01, 1. ), VALE_REFE = 1. ) )

Vérification d’une fonction#

li1=DEFI_LIST_REEL(    DEBUT=0.,

INTERVALLE=_F(JUSQU_A=2*pi, PAS=2*pi/20), )

f1=FORMULE( NOM_PARA=’INST’,

VALE=’sin(INST) + cos(INST)’, )

fonc=CALC_FONC_INTERP ( FONCTION=f1,

LIST_PARA=li1, NOM_RESU=’DEPL’, INTERPOL=’LIN’, )

TEST_FONCTION(

# on teste un attribut de la fonction

ATTRIBUT=_F( FONCTION=fonc, ATTR=’INTERPOL’, ATTR_REFE=’LIN LIN’,),

# on teste une valeur de la fonction

VALEUR=_F ( FONCTION=fonc, VALE_PARA=pi, REFERENCE=”ANALYTIQUE”, VALE_CALC=-1., VALE_REFE=sin(pi)+cos(pi), ), )