2LP manuel

Original: http://www.sci.brooklyn.cuny.edu/~lbslab/2lphelp.html#Keywords%20and%20Terms.

2LP manuel : Essentials et Concepts

Essentials et Concepts

Déclarations
Une déclaration est une contrainte, un test une assignation, un appel de procédure, un bloc réalisé avec d’autres instructions à l’aide d’accolades, parmi les mentions de contrôle continuent, briser, retournent, ou d’une instruction composée construit avec l’un de l’autres constructions de programmation de 2LP. Une déclaration en 2LP réussit ou échoue.
Accolades et blocs
Déclarations en 2LP peuvent être regroupées en un bloc d’instructions simples en les plaçant entre accolades. Les déclarations au sein d’un bloc sont évoquées comme une unité.
Procédures
Une procédure a la forme >
proc_name(<parameters>)
{
<local declarations>
<statements>
}
La procédure doit être appelée 2lp_main()
Types
La langue 2LP prend en charge quatre types de données : int, double, string et continue. Les types doubles et int sont les mêmes types que C et C++, c’est-à-dire int est le type integer et double est flottante caractères points. Le chaîne de type est analogue au char * en C. tableaux de chacun des quatre types de base peuvent être déclarés.
Expressions
Une expression affine et son type sont définis par induction. Expressions affines les plus élémentaires sont des identificateurs et constantes qui ont leurs types donnés. C’est le cas de base de l’induction. Une expression affine est alors définie comme un identificateur, une constante ou une expression composée à partir des expressions affines plus simples. Une expression composée hérite son type de ses mandants. Regardons quelques exemples :
Expressions et Types
D‘expression              Type
a int or double
b int ou double
X continu
X + a continu
(X + a) continu
b*(X + a) continu
floor(b*(X+a)) double
Y – floor(b*(X + a)) continu

 

Plus formellement, les expressions composées sont construites par les constructions suivantes :
function ( <affine expression> )
( <affine expression> )
<unary plus/minus> <affine expression>
<affine expression> <binary operator> <affine expression>
Pour les termes composés formés en appliquant une fonction, l’expression résultante affine a le type qui est retourné par la fonction. Mettre des parenthèses autour d’un terme produit une nouvelle période d’application du même type ; de même, faisant précéder une expression unaire, plus ou moins donne une expression du même type.
En combinant les expressions au moyen d’opérateurs binaires le type continu domine double et les types continus et double les deux dominent int. Il existe deux restrictions. En formant une composé expression affine, si l’opérateur binaire est *, alors l’argument de la main gauche ne peut pas être de type continu ; Si l’opérateur est, ni l’argument peut être de type continu.
Par conséquent, la règle fondamentale est qu’une expression affine de type continu ne peut pas être utilisée comme argument de main gauche d’une multiplication, ou comme des arguments à une division. L’analyseur de 2LP vérifie que des expressions complexes donnent des contraintes linéaires en vérifiant que cette règle est respectée. Ainsi, par exemple, la ligne de code
b <= 1.5*(X + 1)*(Y - 12*X); 
ne peut pas être analysée correctement parce que l’expression (X + 1) est utilisé comme un coefficient.
Variables locales et globales.
Vous pouvez déclarer des variables locales et globales de tous types. Les variables locales de type continu sont de classe de stockage statique. Cela signifie que chaque fois qu’une procédure est appelée son locales variables continues indiquent les mêmes variables que dans précédents appels. Les contraintes construits avec ces variables restent en vigueur après que la procédure se termine avec succès.
Opérateurs relationnels.
Les opérateurs relationnels sont ==, < =, &gt; =,! =, <, et >. Les trois premiers sont appelés opérateurs relationnels fermés ; les trois seconde sont appelés les opérateurs relationnels strictes. Les opérateurs relationnels stricts! =, >, et < utilisable uniquement dans les tests et non dans les contraintes.
Contraintes.
Une contrainte est un énoncé déclaratif qui impose des relations sur les variables continues. Officiellement déclaré, une contrainte est une expression de la forme
<affine expression> <closed relational operator> <affine expression> 
au moins une des expressions affines est de type continu. L’opérateur relationnel fermé peut être ==, < =, ou > =. Lorsqu’une contrainte réussit, il est conforme à la région faisable définie jusqu’à présent et est ajouté aux contraintes déterminantes de la région. Toutefois, si une nouvelle contrainte est ajoutée et aucun point se situant dans l’actuelle région faisable ne répondre à la nouvelle contrainte, la nouvelle contrainte échoue.
Essais
Un test compare deux expressions qui sont de type double ou int. formellement, un test est une expression de la forme
<affine expression> <relational operator> <affine expression> 

 

les expressions affines ne sont pas de type continu. Comme avec les contraintes, tests de réussissent ou l’échouent. Cependant, contrairement aux contraintes, essais n’affectera pas le point actuel de région ou d’un témoin possible. Les opérateurs stricts! =, >, et < utilisable uniquement dans les tests et non dans les contraintes. Les expressions de type chaîne permet pas dans les tests.
Affectation
L’opération fondamentale sur les variables de types int et double est l’opération de cession. Cela prend la forme
<variable identifier> = <affine expression>; 
la variable et l’expression affine sont aussi bien de type int ou double.
L’opération fondamentale sur les variables de type string est aussi l’opération d’assignation. Cela prend la forme
<<variable identifier> = <variable identifier or constant>;
les identificateurs de variables et de la constante sont tous deux de type string.
À la différence des contraintes et des tests, une instruction d’assignation toujours réussit.
Point de témoin
Un point d’angle sur un polyèdre est appelé un sommet. Le solveur de contrainte de base simplex maintient la région faisable avec un sommet distingué ; ce sommet s’appelle le point de témoin.
Conversion de type.
Lorsqu’une variable de type continu est utilisée dans un appel à une fonction intégrée et le type de paramètre est double alors le témoin point de valeur sont utilisé. Si une variable ou une expression de type double est utilisée dans une procédure ou fonction intégrée ou une procédure définie par l’utilisateur l’on s’attend à une valeur integer, la valeur est tronquée ; Si une variable ou une expression de type int est utilisée alors qu’une double est prévue, la valeur est convertie en type double.

2LP manuel : référence du langage
Référence du langage
Variables de boucle
Boucle variables sont introduites dans les en-têtes d’et les boucles ou les boucles, et c_or en boucle. Par exemple, les variables qu’i, j et k sont boucle variables dans les segments de code ci-dessous.
and(int i=0;i<N;i++) { ... }
or(int j=0;j<M;j++) { ... }
Pour les boucles, ou des boucles et des boucles de c_or, la variable introduite comme une variable de contrôle de boucle ne peut pas être assignée dans le corps de la boucle et ne peut être passée par valeur dans un appel de procédures qui se produit dans le corps de la boucle. Si le traçage a lieu à un point de choix qui s’inscrit dans le cadre du corps de la boucle, la variable de contrôle de boucle est rétablie à sa valeur lors de la création du point de choix. Portée de la variable contrôle de boucle est réservée au corps de la boucle. Notez que cela est différent des conventions ANSI C et C++ la variable de boucle reste disponible jusqu’à la fin de la procédure englobante.
L’incrément instruction i ++ ne peut être utilisé dans l’attribution de l’étape dans un en-tête d’une boucle, ailleurs je = i + 1 faut servir. Une remarque similaire détient pour décrémente d’unité.
Conjonction
Conjonction peut être exprimée de deux façons. Le premier est par simple juxtaposition :
<statement> <statement> … <statement> 
La deuxième façon est par le biais de la boucle. Le mot clé et commence la boucle et est suivie d’un en-tête d’une boucle. La forme générale de l’en-tête d’une boucle est
<initial assignment>; <loop condition>; <step assignment> 
L’affectation initiale crée et Initialise une variable nouvelle, appelée la variable contrôle de boucle. L’affectation de l’étape assigne une nouvelle valeur à la variable de contrôle de boucle. Cela permet un large éventail de moyens de mettre à jour la variable de boucle.
L’en-tête d’une boucle est suivie d’une déclaration qui est appelée le corps de la boucle. Comme pour toutes les constructions de boucle en 2LP, contrôle de la boucle variable dans la boucle ne peut être attribué que dans l’en-tête d’une boucle et non dans le corps de la boucle, et sa valeur est accessible une fois quittée la boucle.
Boucles de Sigma
Le sigma de mot-clé commence la boucle et est suivi d’un en-tête qui a la forme d’une boucle
sigma (<initial assignment>; <loop condition>; <step assignment>) 
À la différence des autres constructions de la boucle, dans cette boucle, l’État doit être un test sur la variable de contrôle. Ce test est de la forme
<control variable> <relational operator> <affine expression>
l’expression affine est de type int ou double. L’opérateur relationnel peut être < =, &gt; =, ==, <, >, ou! =.
La valeur de la variable de contrôle est modifiée après chaque passage dans la boucle par la cession de l’étape qui assigne une valeur à la variable de contrôle. Notez que ce formulaire permet de changer à la variable de contrôle par incréments de l’éboutage unité. Par exemple, l’index pair des éléments d’un tableau de 10 éléments appelé b en résumé, on écrirait
a = sigma(int i=0;i<10;i=i+2) b[i]; 
Lorsque nous utilisons les incréments de l’unité, nous pouvons remplacer i ++ pour l’instruction i = i + 1. De même, pour décrémente d’unité, nous utilisons i = i-1 ou i–.
La portée de la boucle de sigma est l’opérande qui suit immédiatement l’en-tête d’une boucle, et l’expression de boucle de sigma a le même type tel que ce terme. Ainsi
sigma(int i=0;i<N;i++) a[i]*(X[i] - b[i])
est de type continu et
sigma(int i=0;i<N;i=i+2) i
est de type int. Un autre point : si jamais succède à l’essai dans la boucle, la boucle retourne 0. Par exemple, l’expression
sigma(int i=0;i<0;i=i+2) i
renvoie la valeur 0 parce que le test 0 < 0 échoue.
Disjonction persistante
Disjonction persistante s’exprime par la soit / ou construire. La syntaxe est :

either <statement 1>
or <statement 2>

or <statement n>

 

Disjonction conditionnelle est proche si/alors/sinon en esprit et en sémantique. En fait

c_either <statement>
or <statement>

équivaut à

if <statement>
then ; // Null statement
else <statement>

Les instructions sont exécutées dans l’ordre jusqu’à ce que l’un d’eux réussit ou ils sont tous échouent. Si aucun d’entre eux réussit le c_either / ou de l’instruction elle-même échoue. Si la première instruction pour réussir est < déclaration j’ai > je < n, le programme passe devant le c_either / ou déclaration mais aucun point de choix est créé. Cela signifie que si une déclaration ultérieure échoue, contrôle ne retourne pas à le c_either / ou déclaration.
Disjonction conditionnelle peut aussi être exprimée par la construction de boucle c_or. La syntaxe est :
c_or(<initial assignment>; <loop condition>; <step assignment>)
<statement>
La variable dans la cession initiale est appelée une variable de boucle ou de la variable contrôle de boucle. Son champ d’application est le <statement>. Le <statement>est appelé le corps de la boucle. La sémantique de cette boucle est comme suit : la variable de boucle est initialisée ; la < condition de boucle > est exécutée et s’il échoue la boucle que vous quittez sans succès. Si < condition de boucle > réussit, la boucle continue. Si <statement>réussit, la boucle s’arrête avec succès mais aucun point de choix n’est enregistré. Si une instruction break est exécutée dans le corps de la boucle, la boucle est quittée avec échec et aucun point de choix n’est créés. Si une instruction continue est exécutée dans le corps de la boucle, tous les points de choix créés dans le corps de la boucle sont supprimés ; le contrôle est retourné vers le haut de la boucle.
Implication et instructions conditionnelles.
La syntaxe de l’instruction d’implication en 2LP est
if <statement>
then <statement>
Si la déclaration antérieure réussit, la déclaration qui en résulte est appelée ; Si le conséquent échoue, la fi/instruction échoue, puis, dans le cas contraire il réussit. Si l’instruction antecedent échoue, la fi/puis instruction réussit sans appeler l’instruction qui en résulte. La fi/puis/else instruction utilise la syntaxe suivante :
if <statement>
then <statement>
else <statement>
Dans cette construction, si l’antécédent échoue, l’instruction qui suit sinon est appelée. L’ensemble si/alors/sinon réussit selon le succès ou l’échec de l’instruction qui suit l’autre. A titre d’exemple, considérez l’instruction
if X >= Y;
then Z <= 100;
else Z >= 150;
Si la contrainte X > = Y est conforme à l’actuelle région faisable, puis le conditionnel se réduit à la conjonction X > = Y ; Z < = 100. Si la contrainte X > = Y n’est pas conforme à l’actuelle région faisable, Z < = 100 n’est pas appelé mais la contrainte Z > = 150 est essayé ; dans ce cas, si ce n’est pas réalisable, l’instruction if/then/else échoue. L’interprétation de l’implication des contraintes généralise la sémantique de programmation standard pour if/then/else. Lorsque les contraintes ne sont pas impliqués, les constructions conditionnelles dans 2LP ont leur sens habituel. Ainsi, par exemple, si a et b sont de type int ou double, le segment de code

if a > b;
then printf("Good morning world");
else printf("Good evening world");

affichera « monde Good morning » uniquement si le test un > b réussit ; dans le cas contraire, elle s’imprime « monde Bonsoir. »
Point de choix.
Un point de choix est créé par un ou l’autre / ou déclaration ou par un ou une boucle. Points de choix sont le mécanisme interne pour soutenir la disjonction persistante. À défaut, le code retourne au dernier point de choix créé qui a toujours des solutions de rechange ouvertes. Ce mécanisme est robuste qu’un point de choix sera retourné au même après que vous quittez la procédure dans laquelle il est créé.
Caractéristiques de préprocesseur.
2LP fournit une fonctionnalité de préprocesseur, qui constitue une étape préliminaire dans la compilation. Les deux fonctionnalités prises en charge sont #define et #include.
La fonctionnalité de #define est utilisée pour remplacer un jeton avec une séquence arbitraire de caractères, la substitution peut être désactivée en #undef. Substitutions sont faites uniquement pour les jetons et n’ont pas lieu dans les chaînes entre guillemets. La forme générale est :

#define <identifier> <replacement string>
#undef <identifier>

 

L’utilisation la plus courante de #define est abstrait Dimensions :
#define N 10
continuous X[N];
Une autre utilisation courante fournir sucre syntaxique. Deux exemples sont :
#define do_and_undo not not //double negation
#define until_break and(;;) //infinite loop
#define until_success or(;;) //infinite loop
Cette fonctionnalité de préprocesseur ne supporte pas les macros à l’aide d’arguments.
La fonctionnalité de #include est utilisée pour l’inclusion de fichiers. N’importe quelle ligne de la source du formulaire

#include filename-in-quotes

peut être utilisé. Vous cherchez le fichier commence se trouvait le programme source. Fichiers inclus peuvent contenir des lignes #include.

Cette fonction permet d’éditer et exécuter des modèles qui seraient trop grands pour l’éditeur si regroupés en un seul fichier.

2LP manuel : Mots clés et termes
Mots clés et termes.
2lp_main()
Ce mot clé doit être le nom de la procédure de la procédure principale.
absgap
absgap(double)
La procédure absgap crée un écart entre la dernière solution trouvée dans un bloc de find_max ou find_min. Exemple :
find_max: Z;
subject_to {
absgap(1.0);
search();
}
et
Ce mot-clé utilisé au code un velcro. Par exemple
and(int i=0;i<N;i++) 
Voir aussi conjointement.
Boolean
Le mot clé boolean est utilisé pour créer des fonctions externes qui la réussissent ou l’échouent. La fonction externe doit retourner un entier. Par exemple :
extern boolean start_empty_job(int,int); 
pause
L’instruction break est utilisée pour sortir soit un et, un, ou en boucle boucle ou un c_or. Si elle est utilisée dans une boucle et l’et succède à boucle. Si elle est utilisée dans un ou boucle boucle ou c_or, la boucle échoue et renvoie sans avoir créé les points de choix.
c_either
Ce mot-clé indique que la disjonction est conditionnelle comme dans C/C++.
Voir aussi la disjonction conditionnelle.
c_or
Ce mot-clé fait suite à une déclaration de c_either lorsque vous utilisez une disjonction conditionnelle ou commence une construction de boucle c_or.
Voir aussi la disjonction conditionnelle.
ceil
double ceil(double) 
Cette fonction, lorsqu’elle est appelée avec un double revient avec la prochaine plus grande valeur de l’entier. Lorsqu’elle est appelée avec une variable continue, elle retourne la valeur d’entier du prochaine plus élevée du point témoin de cette variable.
continuer
Ce mot clé est utilisé dans le corps d’et, ou et boucles de c_or. Dans une boucle du corps est quittée avec succès et le contrôle est retourné à la tête de la boucle. Dans un ou boucle le corps est quittée sans succès et le contrôle est retourné à la tête de la boucle ; aucun point de choix qui ont été créés dans le corps de la boucle n’est conservés.
continu
Le mot clé continu est utilisé pour créer de stockage pour les variables continues. Exemple :
continue X, Y, Z [10] ;
Voir aussi les Types.
double
Le mot clé double est utilisé pour créer de stockage pour les variables double. Exemple :
double x,y,a[40]; 
Voir aussi les Types.
d’autre
Ce mot-clé indique le début de l’autre partie d’une instruction if/then/else.
Voir aussi implicitement et instructions conditionnelles.
ou l’autre
Ce mot clé est utilisé pour indiquer une disjonction persistante. Soit la construction est suivie d’une ou plusieurs ou des constructions.
Voir aussi la disjonction persistants.
sortie
exit() 
Cette procédure prend fin le code 2LP.
extern
Ce mot clé est utilisé pour raconter le système 2LP que les variables ou les procédures qui suivent sont effectivement déclarés dans une DLL externe. Ce mot clé doit être suivi d’un des types suivants : int, double, boolean, ou annuler. Exemple :
extern int wait_list[QUEUESIZE][JOBS];
extern boolean goal(int);
FABS
double fabs(double) 
Cette fonction, lorsqu’elle est appelée avec un double retourne la valeur absolue de la variable. Lorsqu’elle est appelée avec une variable continue, elle retourne la valeur absolue du point témoin de cette variable. Exemple :
d = fabs(wp(X)); 
find_all
Le mot-clé find_all doit être suivi d’une déclaration :
find_all <statement> 
Après que <statement>réussit, retours en arrière se déroule et la solution suivante à <statement>est recherchée. Ce processus se poursuit jusqu’à ce que toutes les solutions ont été trouvées. Quand aucuns plus de solutions ne sont possibles, le find_all sort avec succès sans avoir changé la région faisable d’origineToutefois, si <statement>elle-même ne réussit jamais, puis la find_all <statement>échoue également. Exemple :
find_all {
solve_salt_and_mustard();
count = count + 1;
}
find_max
Le mot-clé find_max est utilisé avec le subject_to mot clé utiliser une branche et la recherche lié pour trouver la valeur maximale d’une variable ou une expression (la fonction objective) sous réserve des conditions dans le subject_to bloc. Cette construction oblige le code pour contraindre la fonction objective d’être aussi bonne que les précédentes solutions trouvées. Le find_max construire échoue si qui suit l’instruction le subject_to échoue. À la sortie du find_max construct contracte la région faisable à un seul point, à savoir la meilleure solution qui a été trouvé. Exemple :

find_max: Return;
subject_to

new_central_loop();

 

find_min
Le mot-clé find_min est utilisé avec le subject_to mot clé utiliser une branche et la recherche liée à trouver la valeur minimale d’une variable ou une expression (la fonction objective) sous réserve des conditions dans le subject_to bloc. Cette construction oblige le code pour contraindre la fonction objective d’être aussi bonne que les précédentes solutions trouvées. Le find_min construire échoue si qui suit l’instruction le subject_to échoue. À la sortie du find_min construct contracte la région faisable à un seul point, à savoir la meilleure solution qui a été trouvé. Exemple :

find_min: Cost; subject_to

and(int i=0;i<ITEMS;i++)

Serving[i] == k;

 

plancher
double floor( double ) 
Cette fonction, lorsqu’elle est appelée avec un double renvoie l’entier le plus proche moins ou égal à lui-même. Lorsqu’elle est appelée avec une variable continue, elle renvoie l’entier le plus proche inférieur ou égal à son point de témoin.
If
Le mot clé pour la première partie d’une instruction if/then/else.
Voir aussi implicitement et instructions conditionnelles.
int
Utilisé pour créer de stockage pour les variables integer. Exemple :
int i,j,k[40]; 
Voir aussi les Types.
Integral
integral( continuous ) 
La fonction intégrante réussit si le paramètre est entier au sein d’une valeur de. Exemple :

no_injuries()
{

and(int i=0;i<N;i++)

integral(X[i]);

}

 

lb
double lb( continuous ) 
Cette fonction retourne la limite inférieure actuelle de la variable continue passée comme un paramètre. La limite inférieure actuelle est la limite inférieure que le solveur simplex a pour cette variable. Exemple :

check_bound(continuous R, int dir, double limit)

{

if dir == 1;
then ub(R) >= limit;
else lb(R) <= limit;

}

Voir aussi ub.
Max

max: <affine expression>

Cet opérateur se déplace le témoin pointent vers un sommet de la région faisable pour lesquels l’expression affine a la valeur maximale possible.

Voir aussi min.
min

min: <affine expression>

Cet opérateur se déplace le témoin pointent vers un sommet de la région faisable pour lesquels l’expression affine a la valeur minimale possible.
Voir aussi max.
Inn
double nint( double )
Cette fonction, lorsqu’elle est appelée avec un double revient avec la valeur de l’entier le plus proche de soi. Lorsqu’elle est appelée avec une variable continue, elle renvoie l’entier le plus proche de son point de témoin.
pas

not <statement>

Le mot clé non suivi d’instruction réussit si <statement>échoue et à l’inverse, la négation échoue si <statement>réussit. La région faisable est restaurée à son état précédant l’exécution de la construction, quel que soit son succès ou son échec. Exemples :

if not X <= Y;
then printf("The constraint would fail\n");
else printf("The constraint would succeed\n");

if not p();
then printf("A call to p() can be successful\n");
else printf("A call to p() can not be successful\n");

 

objcdn
double objcdn( continuous ) 
Cette fonction renvoie une estimation réelle ou conservateur de combien le coefficient de la variable continue peut être diminué sans nécessiter un changement dans le point de témoin. qui donne la solution optimale.
Voir aussi objcup.
objcup
double objcup( continuous ) 
Cette fonction renvoie une estimation réelle ou conservateur de combien le coefficient de la variable continue peut être augmenté sans nécessiter un changement dans le point de témoin qui donne la solution optimale.
Voir aussi objcdown.
ou
Ce mot clé est utilisé après une autre instruction ou au code une ou boucle. Par exemple :

or(int i=0;i<N;i++)

X[j] == i;

 

Voir aussi la disjonction persistants.
printf
Ce mot a la même syntaxe que dans C. Il prend en charge les options de format standard ANSI C telle qu’elle figure dans le langage de programmation C, B. Kernighan et D. Ritchie, Prentice Hall.
aléatoire
double random() 
Cette fonction retourne un flottement nombre à virgule dans l’intervalle (0,1). Les appels successifs produisent une séquence Pseudo-aléatoire. Le générateur de nombres pseudo-aléatoires sous-jacent est amorcée par un appel à la graine
gamme
double range ( continuous ); 
Cette fonction renvoie une estimation du montant que la limite sur une variable peut être modifiée sans en changer son coût réduit. Cette estimation sera exacte ou conservateur ; sur cette plage le coût réduit est égal au prix d’ombre.
RC
double rc( continuous ); 
Cette fonction retourne le coût réduit d’une variable continue.
retour
Cette déclaration quitte la procédure actuelle et renvoie à la procédure appelante. Exemple :

if k==0
then {

a = 15;
return;

}

 

semences
void seed(int) 
Un appel à cette procédure graines le générateur de nombres pseudo-aléatoires intégré. Séquences pseudo-aléatoires sont créés par les appels à l’aléatoire.
Sigma
Ce mot-clé est pour l’écriture d’une contrainte dans une notation similaire à l’utilisation des mathématique ordinaire pour l’équation

 

Par exemple, l’expression 2LP est
sigma(int i=0;i<100;i=i+1) a[i]*X[i] == b; 
chaîne
La chaîne de mot clé est utilisée pour créer de stockage pour les chaînes de caractères. Exemple :
string s,t,u[12];
subject_to
Ce mot clé est utilisé avec le find_min et find_max Mots-clés. Exemple :
find_min: Z;
subject_to
search();
puis
Ce mot clé est utilisé dans le cadre d’une instruction if/then/else.
Voir aussi implicitement et instructions conditionnelles.
UB
double ub( continuous ) 
Cette fonction retourne la limite supérieure actuelle de la variable continu passée comme un paramètre. L’actuelle limite supérieure est la limite supérieure que le solveur simplex a pour cette variable. Exemple :

check_bound(continuous R, int dir, double limit)
{

if dir == 1;

then ub(R) >= limit;

else lb(R) <= limit;

}

 

Voir aussi lb.
Sub
Le mot clé void est utilisé pour déclarer des fonctions externes qui sont appelées à partir d’un modèle 2LP et interprétées comme des procédures qui réussissent toujours. Exemple :
extern void insert_states(int); 
WP
double wp(continuous): 
La fonction wp retourne la valeur actuelle que le point de témoin donne à l’expression passée comme un paramètre. Le paramètre de cette fonction doit être une expression affine de type continu.