IBM FileNet P8, Version 5.2.1            

Fonctions numériques

Cette section contient de brèves descriptions des fonctions qui s'appliquent aux valeurs de type flottant et entier.

Tableau 1. Tableau des fonctions qui s'appliquent aux valeurs de type flottant et entier
Fonction Action
abs Renvoie la valeur absolue de la fonction numérique.
bitor, bitand, bitnot Opérateurs booléens qui permettent de manipuler les bits.
convert Convertit un nombre dans un autre type de données ou convertit un autre type de données en nombre.
err_encode Convertit un bloc de données d'erreur FileNet P8 à trois parties en un entier à une partie.
int Tronque toutes les valeurs placées après le séparateur décimal et renvoie la valeur entière d'une expression numérique.
max Renvoie la plus grande valeur d'une liste d'expressions de tout type de données pris en charge.
min Renvoie la plus petite valeur d'une liste d'expressions de tout type de données pris en charge.
mod Renvoie le reste d'une division (modulo).
numbertostring Convertit une expression numérique en une expression de chaîne avec un masque spécifié.
random Renvoie un nombre entier aléatoire compris dans un intervalle donné.
sizeof Renvoie la taille d'un tableau.

abs

Cette fonction renvoie la valeur absolue d'une expression flottante ou entière. Utilisez la syntaxe suivante :
abs (num_expr)
où num_exp est une expression dont le résultat est une valeur flottante ou entière. Par exemple :
abs (SalePrice - PurchasePrice)

bitand, bitor et bitnot

Ces fonctions permettent de manipuler des bits avec des opérateurs booléens. Elles s'utilisent pour effectuer de nombreuses tâches, par exemple pour masquer des paramètres ou extraire des bits. Toutes ces fonctions peuvent exécuter des opérations booléennes sur 32 éléments simultanément au maximum.

Si vous connaissez le langage de programmation 'C', notez que bitand, bitor et bitnot correspondent respectivement aux opérateurs logiques and (&), or (|) et not (~). Dans le cas contraire, regardez les nombres comme des valeurs binaires (par exemple, 123 équivaut à 1111011).

Ces fonctions utilisent des entiers de 32 bits (de 0 à 42946967295) comme entrée et renvoient des entiers compris dans le même intervalle comme résultat. Utilisez la syntaxe suivante :
bitand (expr1, expr2)

bitor (expr1, expr2)

bitnot (expr)
où expr1 et expr2 sont des entiers de 32 bits.
Pour afficher des informations et des exemples pour chaque fonction, sélectionnez une rubrique dans la liste ci-dessous.

bitand

La fonction bitand applique l'opérateur "and" aux bits correspondants dans deux entiers. Il s'agit d'une comparaison bit par bit dont le résultat est un nouvel entier. La comparaison observe les règles suivantes :
  • Si les deux entiers contiennent un 1 à la même position, l'entier généré contient également 1 à cette position.
  • Si les deux entiers contiennent un 0 à la même position, l'entier généré contient également 0 à cette position.
  • Si l'un des entiers contient un 1 et que l'autre contient un 0 à la même position, l'entier généré contient 0 à cette position.
Par exemple, le résultat de l'expression bitand (123, 240) apparaît comme suit :
bitand

     (00000000000000000000000001111011,
         

      00000000000000000000000011110000)
          

  Résultat : 
      00000000000000000000000001110000

bitor

La fonction bitor applique l'opérateur "or" aux bits correspondants dans deux entiers. Il s'agit d'une comparaison bit par bit dont le résultat est un nouvel entier. La comparaison observe les règles suivantes :
  • Si l'un des deux entiers contient un 1 à la même position, l'entier généré contient également 1 à cette position.
  • Si les deux entiers contiennent un 0 à la même position, l'entier généré contient également 0 à cette position.
Par exemple, le résultat de l'expression bitor (123, 240) apparaît comme suit :
bitor
     (00000000000000000000000001111011,
         
      00000000000000000000000011110000)
          
  Résultat :

      00000000000000000000000011111011

bitnot

La fonction bitnot applique l'opérateur "not" à un entier. Il s'agit d'une analyse bit par bit dont le résultat est un nouvel entier. Pour chaque position, le nouvel entier contient le bit opposé au bit initial. Par exemple, si l'entier source contient un 1 à une position donnée, l'entier généré contient 0 à la même position.

Par exemple, le résultat de l'expression bitnot (123, 240) apparaît comme suit :
bitnot
              (00000000000000000000000001111011
  Résultat :
               11111111111111111111111110000100

int

Cette fonction calcule la valeur entière d'une expression flottante en tronquant toutes les valeurs placées après le séparateur décimal. Par exemple, les valeurs flottantes 6,2 et 6,8 sont converties en une valeur entière égale à 6. Le signe de la valeur ne change pas.

Utilisez la syntaxe suivante :
int (num_expr)
où num_expr est une expression dont le résultat est une valeur flottante. Par exemple :
int (365 / 7)

mod

Cette fonction renvoie le reste d'une division (modulo). Notez qu'une erreur d'exécution se produit si vous tentez de diviser une valeur par zéro.

Utilisez la syntaxe suivante :
mod (num1, num2)
où num1 et num2 sont des variables flottantes ou entières pouvant contenir des valeurs négatives.
Dans l'exemple suivant, la fonction renvoie le reste de la division de la valeur de NumberOfDays par 7.
mod (NumberOfDays, 7)
Notez que le signe de num2 détermine le signe du résultat de la fonction mod (quand ce résultat est différent de 0) :
If num2 > 0,

		0 <= mod (num1, num2) < num2

If num2 < 0,

		num2 < mod (num1, num2) <= 0

random

Certaines applications ont besoin de générer un nombre aléatoire, par exemple pour effectuer des échantillonnages au hasard. Cette fonction renvoie un nombre entier aléatoire compris dans un intervalle donné. Elle demande de fournir un entier comme paramètre pour déterminer l'intervalle.

Utilisez la syntaxe suivante :
random (num)
où num est un entier compris entre 2 et 32768 (inclus). L'intervalle va de 0 à (num - 1). Dans l'exemple ci-dessus, si num = 23, le nombre aléatoire est compris entre 0 et 22.

err_encode

Cette fonction convertit un bloc de données d'erreur FileNet P8 à trois parties en une valeur entière que vous pouvez comparer à un code retour renvoyé par un appel à un point d'entrée WorkFlo Application Libraries (WAL). WAL renvoie les codes de retour quand des exceptions se produisent au cours du traitement normal des données (par exemple une fin de fichier dans un traitement simple) ou quand une erreur se produit.

La première utilisation de la fonction err_encode sert à baser la suite du traitement d'un élément de travail sur les résultats renvoyés par une opération qui appelle WAL. Habituellement, ce genre d'opération est suivie d'une instruction système Branch. Quand cette instruction Branch s'exécute, l'élément de travail suit le chemin de traitement déterminé par le code de résultat renvoyé par l'opération précédente. Par exemple, utilisez la fonction err_code dans la définition de branchement pour indiquer que, si <return code> = err_encode (80, 0, 2), l'élément de travail suit un chemin de traitement donné et en suit un autre si <return code> = err_encode (80, 0, 5).

Utilisez la syntaxe suivante :
err_encode (mod_num, func_num, err_num)
où :
Tableau 2. Paramètres et description de la fonction err_encode
Paramètre Description
mod_num Première partie du code de résultat. Il s'agit d'une expression de type nombre entier (compris entre 0 et 255) qui indique quel service, bibliothèque ou application est la source de l'erreur.
func_num Deuxième partie du code de résultat. Il s'agit d'une expression de type nombre entier (compris entre 0 et 255) qui indique de quelle fonction ou de quel module provient l'erreur ou à quelle catégorie elle appartient.
err_num Troisième partie du code de résultat. Il s'agit d'une expression de type nombre entier (compris entre 0 et 65535) qui indique le numéro de l'erreur.


Last updated: March 2016
bpfe010.htm

© Copyright IBM Corp. 2016.