Utilisation d'opérateurs numériques et de fonctions dans la logique avancée
Vous pouvez définir des paramètres pour plusieurs types différents. Cette section fournit des exemples d'utilisation des opérateurs et des fonctions sur les paramètres numériques dans la logique avancée.
Opérateurs pour les paramètres numériques
Vous pouvez définir des paramètres pour des types de nombres entiers ou réels. Bien que ces types correspondent aux définitions de type Windchill auxquelles le paramètre peut être mappé, ils sont mappés en interne aux types primitifs Java de type long et double, respectivement, permettant leur utilisation dans n'importe quelle expression Java valide en tant que variables longues et doubles.
Les expressions peuvent être définies à partir des éléments suivants :
• Le champ Expression d'un paramètre définissant une valeur réelle ou par défaut du paramètre. Pour plus d'informations sur l'utilisation des expressions dans les paramètres, consultez la rubrique Onglet Informations de la fenêtre Modifier paramètre.
• Une contrainte de type Expression requiert que l'expression soit évaluée comme une valeur booléenne. Pour plus d'informations sur les types de contraintes des expressions, consultez la rubrique Editeur d'expressions.
• Les expressions peuvent également être utilisées dans un tableau de cas avancé. Pour plus d'informations sur les tableaux de cas avancés, consultez la rubrique Editeur de tableau de cas.
Opérateurs arithmétiques
Les opérateurs arithmétiques peuvent être utilisés avec des paramètres numériques dans les expressions. Il s'agit notamment des opérateurs d'addition binaire (+), de soustraction (-), de multiplication (*) et de division (/). Voici quelques exemples de contraintes d'expression :
• 2 * a – 3 * b == c / d + e / 3
• A == 2.5 * B / C – D / 7.5
Les opérateurs à une seule entrée ou unaires - et + peuvent également être utilisés (+A est équivalent à A).
• A == -B + 2 * C
• D = +A – (-C)
L'opérateur modulo (%) peut être utilisé pour calculer le reste de la division du premier argument par le second argument :
A == B % 7
Opérateurs relationnels
Les opérateurs relationnels sont utilisés pour comparer des sous-expressions numériques dans des contraintes d'expression qui doivent avoir pour résultat une valeur booléenne. Ils incluent les opérateurs suivants :
• égal à (==)
• supérieur à (>)
• inférieur à (<)
• supérieur ou égal à (>=)
• inférieur ou égal à (<=)
• différent de (!=)
 |
L'opérateur "égal à" doit être écrit sous la forme "==", et non "=".
|
Lorsque le côté gauche ou droit de l'expression avec l'opérateur "==" contient une expression unique, l'expression est traitée comme une affectation (=). Par exemple, dans les contraintes d'expression suivantes :
• A == 2 * B + 3 * C
• B / 4 - C / 3 == A
Si les valeurs des paramètres B et C sont connues, la valeur du paramètre A sera calculée en fonction des formules. Dans les exemples ci-dessus, définissez le paramètre A en tant que paramètre non-entrée, afin que sa valeur soit calculée par la formule au lieu d'être entrée par l'utilisateur, puis calculée par la formule. Cela signifie également que l'ordre des entrées est important, où B et C sont définis avant l'apparition de paramètre A. S'ils sont définis dans tout autre ordre, dans lequel le paramètre A se voit affecter sa valeur avant les paramètres B et C, l'expression est traitée comme une expression booléenne où la valeur du paramètre A est comparée à celle de la formule évaluée en fonction des valeurs de B et C.
|
|
Lorsque les deux côtés contiennent plusieurs paramètres, tous les paramètres doivent être connus avant que les contraintes de l'expression ne puissent être évaluées.
|
Référencement de méthodes ou de fragments d'expression pour les paramètres numériques dans les fonctions
Les paramètres numériques peuvent également être utilisés comme arguments les fonctions prêtes à l'emploi, standard Java et définies par l'utilisateur. Les sections suivantes fournissent des alternatives pour référencer une méthode ou un fragment d'expression.
Dans les exemples ci-dessous, envisagez D_1, D_2, D_3, D_4, D_5 et D_6 en tant que paramètres réels (Java double) et P_1, P_2, P_3 et P_4 en tant que paramètres entiers (Java long). En outre, GeomFunctions est le nom de la classe définie par l'utilisateur, à partir du lot ext.geom, qui contient des fonctions géométriques.
Utilisation du chemin de classe complète vers la méthode
Le nom complet (<package path>.<class name>.<method name>) peut être utilisé pour spécifier la fonction qui transmet les paramètres en tant qu'arguments. Les exemples suivants illustrent cette approche :
• D_1 == java.lang.Math.cos(D_2) + java.lang.Math.sin(D_3)
• P_1 == java.lang.StrictMath.addExact(P_2, P_3)
• D_4 == ext.geom.GeomFunctions.area(D_5, D_6)
Utilisation de déclarations d'importation
Les classes à importer peuvent être spécifiées dans le fichier WT_HOME/codebase/com/ptc/wpcfg/exparser/LookUpService.properties comme suit :
exparser.import.1=java.lang.Math
exparser.import.2=java.lang.StrictMath
exparser.import.3=ext.geom.GeomFunctions
exparser.import.2=java.lang.StrictMath
exparser.import.3=ext.geom.GeomFunctions
Lorsque les déclarations d'importation ci-dessus sont utilisées, vous pouvez omettre le chemin du lot lorsque vous spécifiez la fonction dans les expressions :
• D_1 == Math.exp(D_2)
• P_1 == StrictMath.round(D_3)
• D_3 == ext.geom.GeomFunctions.volume(D_4, D_5, D_6)
Utilisation de déclarations d'importation statiques
Les déclarations d'importation statiques peuvent tout d'abord être spécifiées dans le fichier WT_HOME/codebase/com/ptc/wpcfg/exparser/LookUpService.properties de la façon suivante :
exparser.static.import.1=java.lang.Math
exparser.static.import.2=ext.geom.GeomFunctions
exparser.static.import.2=ext.geom.GeomFunctions
Le chemin du lot et le nom de la classe peuvent être omis, en ne laissant que le nom de la méthode, lorsque vous spécifiez la fonction dans l'expression lors de l'utilisation de déclarations d'importation statiques :
• D_1 == exp(D_2)
• P_1 == round(D_3)
• D_3 == ext.geom.GeomFunctions.volume(D_4, D_5, D_6)
S'il existe une méthode portant le même nom dans plusieurs classes enregistrées dans les importations statiques, une erreur d'exception s'affiche. Par exemple, java.lang.Math et java.lang.StrictMath ont un grand nombre de noms de méthode en commun. L'enregistrement des deux classes en tant qu'importations statiques entraîne des conditions d'erreur lors de l'utilisation de ces méthodes communes dans les formules.
Utilisation d'abréviations (alias) pour les méthodes
Le mappage entre une abréviation pour une méthode et le chemin complet de la méthode peut être défini dans le fichier WT_HOME/codebase/com/ptc/wpcfg/exparser/LookUpService.properties comme suit :
exparser.abbreviation.1=SURFACE_AREA=ext.geom.GeomFunctions.area
exparser.abbreviation.2=ARC_TAN=java.lang.StrictMath.atan
exparser.abbreviation.2=ARC_TAN=java.lang.StrictMath.atan
Une fois le mappage entre une abréviation d'une méthode et son chemin d'accès complet défini, vous pouvez utiliser ces alias pour accéder à la fonction dans l'expression :
• D_1 == ARC_TAN(D_2)
• D_3 == SURFACE_AREA(D_4, D_5)
Cette technique est utile si vous souhaitez redéfinir une méthode à partir d'une classe Java pour qu'elle soit identique au nom d'une fonction dans une autre application telle que Microsoft Excel. Si vous définissez la propriété ato.expression.rendering.context=com.ptc.wpcfg.logic.XLSExpressionRenderingContext dans le fichier WT_HOME/wt.properties, le système ajoute les alias appropriés pour permettre l'accès à la plupart des fonctions numériques, textuelles et logiques par les noms utilisés dans l'application Microsoft Excel. Les fonctions numériques sont les suivantes : ABS, ACOS, ASIN, ATAN, CEILING, COS, DEGREES, FLOOR, INT, LN, LOG, MAX, MIN, MOD, POWER, RADIANS, ROUND, ROUNDDOWN, ROUNDUP, SIN, SQRT, TAN, ACOSH, ASINH, ATANH, COMBIN, COSH, EXP, FACT, LOG10, SIGN, SINH, TANH.
Utilisation de macros
Alors qu'une abréviation fournit un alias pour le chemin de fonction complet d'une fonction unique, une macro est un alias pour un fragment d'expression. C'est utile lorsqu'un fragment d'expression est utilisé plusieurs fois dans plusieurs expressions. Les déclarations d'importation, d'importation statique et d'abréviation sont résolues à la volée lorsqu'une expression est analysée. Tout d'abord, les fragments de macro sont remplacés pour les macros de l'expression. Ensuite, cette dernière est analysée. Comme les autres propriétés du parseur, les mappages de macros sont définis dans le fichier WT_HOME/codebase/com/ptc/wpcfg/exparser/LookUpService.properties comme suit :
exparser.macro.1=AREA=SURFACE_AREA(D_2, D_3)
exparser.macro.2=SUM=java.lang.StrictMath.addExact(P_2, P_3)
exparser.macro.2=SUM=java.lang.StrictMath.addExact(P_2, P_3)
Vous pouvez ensuite utiliser les macros dans les expressions suivantes :
• D_1 == AREA + 10.2
• P_1 == SUM + P_4