Modelib: Model class Reference

Page principale | Hiérarchie des classes | Liste des composants | Liste des fichiers | Composants

# Référence de la classe Model

Classe répresentant le programme lineaire en lui meme. Plus de détails...

`#include <Model.h>`

Liste de tous les membres

## Membres publics
| Model ()
| Model (const Model &)
Model & | operator= (const Model &)
Constraint | Add (const ConstraintBuilder &, const std::string &nom="")
Constraint | Add (const ConstraintBuilder &constraint, const Nom &_nom)
void | Maximize (const Expr &expr, const std::string &nom="")
void | Minimize (const Expr &expr, const std::string &nom="")
Expr | GetObjectif () const
void | SetProblemName (const std::string name="")
string | GetProblemName () const
bool | IsRelaxed () const
void | SetRelaxed (bool _isRelaxed)
bool | RelaxInt2Float (NumVar numVar=NumVar())
bool | RelaxBool2Float (NumVar numVar=NumVar())
void | SetNumVarValues (const std::list< std::string > &noms, const std::list< float > &values)
void | SetConstraintValues (const std::list< std::string > &noms, const std::list< float > &values)
void | GetInfluentLagrangianParam (std::list< LagrangianParam > &listViolated, std::list< LagrangianParam > &listSlacked)
std::vector< LagrangianParam > | GetAllLagrangianParams ()
float | EvalueConstraint (VarId id) const
void | UnrelaxModel ()
std::ostream & | Out (std::ostream &flux=std::cout, const std::string &newline="")
std::ostream & | OutDimensions (std::ostream &flux=std::cout, const std::string &newline="")
std::ostream & | OutNumVarValues (bool withoutNullValue=true, std::ostream &flux=std::cout, const std::string &newline="") const
std::ostream & | OutConstraintValues (std::ostream &flux=std::cout, const std::string &newline="") const
Constraint | GetConstraint (VarId id) const
Constraint | GetConstraint (const std::string &)
bool | RelaxConstraint (VarId id, float lagrangianValue=-Infinity)
bool | Relax (const std::string &name, float lagrangianValue=-Infinity)
void | RenameConstraint (VarId id, const std::string &name)
VarId | GetMaxVarId () const
VarId | GetMaxConstraintId () const
bool | LoadLP (const std::string &, bool verbose=false)
void | RemoveVariable (VarId varId)
void | RemoveConstraint (VarId varId)
void | AddToConstraint (VarId, const Expr &)
void | SetSecondMember (VarId, float)
float | GetSecondMember (VarId) const
void | Clear ()
void | Normalize (bool withoutStrict=true)
void | PrintDual (const std::string &) const
Model | GetDual () const
void | InitSolver (API _API=GLPK, const std::string &_fLP="./tmp.solver.lp", const std::string &_path="")
float | Solve ()
void | SolveInfos (std::string &_operation, std::string &_informations)
double | MatriceOccupation ()
void | SetAPI (API _API)
void | PushOptions (const std::string &_str)
void | RemoveOptions ()
void | ShowMe (bool withoutNullValue=true)
void | PrintFraction ()
void | EndFraction ()
std::string | AddComment (const std::string &comment)
void | SetComment (VarId id, const std::string &comment)
std::string | GetComment (VarId id) const
void | SortieHTML (const std::string &fileName, const std::string &matrixPNG="")
void | SortieLATEX (const std::string &fileName)
## Membres protégés
float | GetLagrangianParamValue (VarId) const
void | SetLagrangianParamValue (VarId, float)
VarId | AddVar (const MuteVar &muteVar, const std::string &)
VarId | GetVarId (const std::string &) const
MuteVar | GetMuteVar (VarId varId) const
NumVar | GetNumVar (VarId varId) const
std::string | GetName (VarId varId) const
void | SetName (VarId varId, const std::string &name)
float | GetMuteVarLB (VarId varId) const
void | SetMuteVarLB (VarId varId, float _value)
float | GetMuteVarUB (VarId varId) const
void | SetMuteVarUB (VarId varId, float _value)
void | SetMuteVarLBStrict (VarId varId, bool _value)
void | SetMuteVarUBStrict (VarId varId, bool _value)
MuteVar::VarType | GetType (VarId varId) const
void | SetType (VarId varId, MuteVar::VarType _type)
VarId | AddExpr (Expr &expr, MatriceCreuse< float > &A)
Expr | GetRelaxedConstraintExpr (VarId id, bool relaxed=true)
void | ComputeObjectif ()
std::ostream & | SurchargeFlux (std::ostream &) const
std::ostream & | SurchargeFluxRelaxed (std::ostream &) const
VarId | GetConstraintId (const std::string &)
## Amis (friends)
class | LagrangianParam
class | Constraint
class | NumVar
std::ostream & | operator<< (std::ostream &, const Model &)

## Description détaillée

Classe répresentant le programme lineaire en lui meme.

Elle contient: -un entier permettant l'attribution d'un numero a chaque variable -un entier permettant l'attribution d'un numero a chaque contrainte -une base de donnee sur les variables du vecteur inconnu -une Matrice creuse representant les contraintes lineaires -une base de donnee sur les contraintes lineaires -une base de donnee de commentaires -un booleen caracterisant le type de fonction objectif -un booleen specifiant si le programme linéaire est relache -un booleen specifiant si l'utilisateur desire un affichage fractionnaire -un booleen specifiant si la solution est optimale -un booleen specifiant si le probleme a ete resolu -un booleen specifiant si le probleme a ete normalise -la fonction objectif sous la forme d'une expression -la valeur de la fonction objectif apres resolution -le nom de la fonction objectif -le nom du programme linéaire -une interface avec les solveurs -un convertisseur pour l'aaffichage fractionnaire

Ce modele est independant d'un environnement Ce modele peut etre modifié par la création de variable et l'ajout de contraintes.
Les variables peuvent etre modifiee par le biais de la classe NumVar.
L'operateur << permet d'afficher le probleme sous la forme d'un fichier LP.

## Documentation des contructeurs et destructeurs

Model::Model | ( |  | ) | `[inline]`

| Constructeur par défaut

Model::Model | ( | const Model & | m | ) |

| Constructeur par copie

## Documentation des méthodes

Constraint Model::Add | ( | const ConstraintBuilder & | c,
|  | const std::string & | nom = ""
| ) |

  | Add une contrainte au modele Paramètres:
  c | la contrainte à ajouter
  nom | le nom de la contrainte
Renvoie: le type de matrice dans laquelle a été insérer la contrainte

std::string Model::AddComment | ( | const std::string & | comment | ) |

  | Ajout d'un commentaire avant la prochaine contrainte si un commentaire était déjà la, il sera écrasé, mais aussi retourné Paramètres:
  comment | la chaine de commentaire sans le "\" l'ancien commentaire

VarId Model::AddExpr | ( | Expr & | expr,
|  | MatriceCreuse< float > & | A
| ) | `[protected]`

  | Fonction permettant d'ajouter la partie linéaire d'une contrainte au modele Il suffit juste de modifier le coefficient de la matrice adéquat pour chaque variable, à savoir celui d'indice (l'identifiant de variable, numéro de contrainte) Paramètres:
  expr | l'expression à ajouter au modèle
  A | la matrice qui correspond au type de contrainte d'ou provient l'expression

void Model::AddToConstraint | ( | VarId | id,
|  | const Expr & | expr
| ) |

  | Ajoute une expression linéaire à la parite linéaire de la contrainte Paramètres:
  id | l'identifiant de la contrainte
  expr | l'expression linéaire à rajouter

VarId Model::AddVar | ( | const MuteVar & | muteVar,
|  | const std::string & | _nom
| ) | `[protected]`

| AddVar permet la création d'une nouvelle variable referencé dans le modele. Seule la classe NumVar appelle cette fonction. Elle est d'ailleurs déclarée en friend spécialement pour pouvoir utiliser cette fonction Renvoie: l'identifiant attribué à la variable

void Model::Clear | ( |  | ) |

| Nettoye le modele

float Model::EvalueConstraint | ( | VarId | id | ) | const

  | Permet de d'avoir l'evaluation de l'expression linÃ©aire d'une contrainte utile dans la resolution lagrangienne Paramètres:
  id | l'identifiant de la contrainte
Renvoie: l'expression de la contrainte relaxÃ©e

std::vector< LagrangianParam > Model::GetAllLagrangianParams | ( |  | ) |

| Renvoie un vecteur contenant tous les multiplicateurs de lagrange du modele Renvoie: Un vecteur de taille egal au nombre de contrainte du probleme

Constraint Model::GetConstraint | ( | const std::string & | name | ) |

  | Récupère une contrainte à partir de son nom Paramètres:
  name | le nom de la contrainte
Renvoie: La contrainte correspondante au nom

Constraint Model::GetConstraint | ( | VarId | id | ) | const

  | Permet d'obtenir la contrainte en fonction de son identifiant Paramètres:
  id | l'identifiant de contrainte
Renvoie: La contrainte correspondant à l'identifiant

VarId Model::GetConstraintId | ( | const std::string & | name | ) | `[protected]`

  | Renvoie l'identifiant de la contrainte en fonction du nom Cette recherche est lente car le nom peut etre n'importe ou dans le stockage optimiser pour les recherches suivant l'identifiant. En cas d'echec on retourne 0 Paramètres:
  name | le nom de la contrainte
Renvoie: L'identifiant de la contrainte nommée name

Model Model::GetDual | ( |  | ) | const

| Permet de calculer le dual du programme dans un Model Renvoie: Le Model correspondant au programme linéaire

void Model::GetInfluentLagrangianParam | ( | std::list< LagrangianParam > & | listViolated,
|  | std::list< LagrangianParam > & | listSlacked
| ) |

  | Remplie les listes listViolated et listSlacked par les coefficients de lagrange correspondant aux contraintes respectivement violÃ©es et laches Paramètres:
  listViolated | liste des contraintes violees
  listSlacked | liste des contraintes laches

float Model::GetLagrangianParamValue | ( | VarId | id | ) | const`[protected]`

  | Recupere le coefficient du multiplicatuer de Lagrange asssocié à la contrainte Paramètres:
  id | li'dentifiant de contrainte

MuteVar Model::GetMuteVar | ( | VarId | varId | ) | const`[protected]`

  | Geter de la variable associée a l'identifiant passé en argument Paramètres:
  varId | l'identifiant
Renvoie: la variable

float Model::GetMuteVarLB | ( | VarId | varId | ) | const`[protected]`

  | Geter de la borne inférieure de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
Renvoie: la borne inférieure

float Model::GetMuteVarUB | ( | VarId | varId | ) | const`[protected]`

  | Geter de la borne supérieure de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
Renvoie: la borne supérieure

std::string Model::GetName | ( | VarId | varId | ) | const`[protected]`

  | Geter du nom de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
Renvoie: le nom de la variable

NumVar Model::GetNumVar | ( | VarId | varId | ) | const`[protected]`

  | Geter de la variable associée a l'identifiant passé en argument Paramètres:
  varId | l'identifiant
Renvoie: la variable sous le formar NumVar

Expr Model::GetRelaxedConstraintExpr | ( | VarId | id,
|  | bool | relaxed = true
| ) | `[protected]`

  | Permet de d'avoir l'expression relaxée une contrainte Paramètres:
  id | l'identifiant de la contrainte
Renvoie: l'expression de la contrainte relaxée

float Model::GetSecondMember | ( | VarId | id | ) | const

  | retourne le coefficient de la contrainte d'identifiant VarId Paramètres:
  id | l'identifiant de la contrainte
Renvoie: Le coefficient de la contrainte

MuteVar::VarType Model::GetType | ( | VarId | varId | ) | const`[protected]`

  | Geter du type de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
Renvoie: le type de la variable (sous le format MuteVar::VarType)

bool Model::LoadLP | ( | const std::string & | _name,
|  | bool | verbose = false
| ) |

  | Chargement d'un fichier LP à partir duquel on va charger le modele Paramètres:
  _name | le nom du fichier LP de destination
  verbose | un flag d'affichage
Renvoie: Vrai si le chargement c'est bien passé

void Model::Maximize | ( | const Expr & | expr,
|  | const std::string & | name = ""
| ) |

  | Définit la fonction à maximiser Paramètres:
  expr | l'expression à maximiser
  nom | le nom de l'expression à maximiser

void Model::Minimize | ( | const Expr & | expr,
|  | const std::string & | name = ""
| ) |

  | Définit la fonction à minimiser Paramètres:
  expr | l'expression à minimiser
  nom | le nom de l'expression à maximiser

Model & Model::operator= | ( | const Model & | m | ) |

| operateur de copie

std::ostream & Model::Out | ( | std::ostream & | flux = std::cout,
|  | const std::string & | newline = ""
| ) |

  | Sortie graphique sous forme brute Paramètres:
  flux | le flux de destination
  newline | le chaine a mettre en bout de ligne

std::ostream & Model::OutConstraintValues | ( | std::ostream & | flux = std::cout,
|  | const std::string & | newline = ""
| ) | const

| Affiche les valeurs des contraintes et leurs états

std::ostream & Model::OutDimensions | ( | std::ostream & | flux = std::cout,
|  | const std::string & | newline = ""
| ) |

| Sortie graphique des dimensions du problème

std::ostream & Model::OutNumVarValues | ( | bool | withoutNullValue = true,
|  | std::ostream & | flux = std::cout,
|  | const std::string & | newline = ""
| ) | const

  | Sortie sur cout des valeurs des variables Paramètres:
  withoutNullValue | qui spécifie si les variables nulles doivent etre affichees

void Model::PrintDual | ( | const std::string & | fileName | ) | const

  | Permet de récuperer le dual du programme linéaire dans un fichier Paramètres:
  fileName | le fichier de sortie

bool Model::Relax | ( | const std::string & | name,
|  | float | lagrangianValue = -Infinity
| ) |

  | Relaxe une contrainte en la multipliant par un multiplicateur de Lagrange et en l'additionnant à la fonction objectif Paramètres:
  nom | le nom de la contrainte
  mult | le multiplicateur de Lagrange
Renvoie: vrai si l'operation s'est bien déroulé

bool Model::RelaxBool2Float | ( | NumVar | numVar = NumVar() | ) |

  | Relaxe les contraintes sur les types de variables ici les variables boolennes si la variable en parametre est la variable nulle on relaxe toutes les varaibles autrement dit RelaxBool2Float() relaxe toutes les variables Paramètres:
  la | variable a relaxee
Renvoie: vrai si l'operation s'est bien déroulée

bool Model::RelaxConstraint | ( | VarId | id,
|  | float | lagrangianValue = -Infinity
| ) |

  | Relaxe une contrainte Paramètres:
  id | l'identifiant de contrainte
  lagrangianValue |
Renvoie: Vrai si la contrainte a ete relaxee avec succes

bool Model::RelaxInt2Float | ( | NumVar | numVar = NumVar() | ) |

  | Relaxe les contraintes sur les types de variables ici les variables entieres si la variable en parametre est la variable nulle on relaxe toutes les varaibles autrement dit RelaxInt2Float() relaxe toutes les variables Paramètres:
  la | variable a relaxee
Renvoie: vrai si l'operation s'est bien déroulée

void Model::RemoveConstraint | ( | VarId | id | ) |

  | Enlève une contrainte du modèle Paramètres:
  id | la contrainte du modèle

void Model::RemoveVariable | ( | VarId | varId | ) |

  | Enlève une variable du modèle Paramètres:
  varId | l'identifiant de la variable dans le modèle

void Model::RenameConstraint | ( | VarId | id,
|  | const std::string & | name
| ) |

  | Renomme une contrainte Paramètres:
  id | l'identifiant de la contrainte à renommer
  name | son nouveau nom

void Model::SetAPI | ( | API | _API | ) |

| Definit le solver

void Model::SetComment | ( | VarId | id,
|  | const std::string & | comment
| ) |

  | Définit un commentaire pour la contrainte d'identifiant id si un commentaire était déjà la, il sera écrasé Paramètres:
  id | l'identifiant de la contrainte
  comment | la chaine de commentaire sans le "\"

void Model::SetConstraintValues | ( | const std::list< std::string > & | noms,
|  | const std::list< float > & | values
| ) |

  | Définit les valeurs des contraintes en fonctions de deux listes correspondant aux nouveaux couples valeur-nom Paramètres:
  noms | la liste des noms de variables à changer
  values | la listes de leurs valeurs reciproques

void Model::SetLagrangianParamValue | ( | VarId | id,
|  | float | value
| ) | `[protected]`

  | Definit le coefficient du multiplicateur de Lagrange asssocié à la contrainte Paramètres:
  id | li'dentifiant de contrainte

void Model::SetMuteVarLB | ( | VarId | varId,
|  | float | _value
| ) | `[protected]`

  | Seter de la borne inférieure de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
  _value | la nouvelle value de la borne inférieure

void Model::SetMuteVarLBStrict | ( | VarId | varId,
|  | bool | _value
| ) | `[protected]`

  | Seter du caractère strict de borne inférieure de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
  _value | la nouvelle value du caractère strict de la borne inférieure

void Model::SetMuteVarUB | ( | VarId | varId,
|  | float | _value
| ) | `[protected]`

  | Seter de la borne supérieure de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
  _value | la nouvelle value de la borne supérieure

void Model::SetMuteVarUBStrict | ( | VarId | varId,
|  | bool | _value
| ) | `[protected]`

  | Seter du caractère strict de borne supérieure de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
  _value | la nouvelle value du caractère strict de la borne supérieure

void Model::SetName | ( | VarId | varId,
|  | const std::string & | name
| ) | `[protected]`

  | Seter du nom de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
  le | nom de la variable

void Model::SetNumVarValues | ( | const std::list< std::string > & | noms,
|  | const std::list< float > & | values
| ) |

  | Définit les valeurs des contraintes en fonctions de deux listes correspondant aux nouveaux couples valeur-nom Paramètres:
  noms | la liste des noms de variables à changer
  values | la listes de leurs valeurs reciproques

void Model::SetSecondMember | ( | VarId | id,
|  | float | bid
| ) |

  | Change le coefficient de la contrainte d'identifiant VarId Paramètres:
  id | l'identifiant de la contrainte
  bid | le nouveau coefficient de la contrainte

void Model::SetType | ( | VarId | varId,
|  | MuteVar::VarType | _type
| ) | `[protected]`

  | Seter du type de la variable associée à l'identifiant passé en argument Paramètres:
  varId | l'identifiant
  le | nouveau type de la variable (sous le format MuteVar::VarType)

void Model::ShowMe | ( | bool | withoutNullValue = true | ) |

  | Affiche les principales caractéristiques du problème Paramètres:
  withoutNullValue | permet de ne pas afficher les variables de valeurs nulles

float Model::Solve | ( |  | ) |

| Resoud le Modele

void Model::SortieHTML | ( | const std::string & | fileName,
|  | const std::string & | matrixPNG = ""
| ) |

  | Création d'un document au format html Paramètres:
  fileName | le nom du document

void Model::SortieLATEX | ( | const std::string & | fileName | ) |

  | Création d'un document au format LaTeX Paramètres:
  fileName | le nom du document

std::ostream & Model::SurchargeFlux | ( | std::ostream & | flux | ) | const`[protected]`

  | Sortie graphique sous forme de flux dans le format LP Paramètres:
  o | le flux à surcharger
Renvoie: le flux surchargé

std::ostream & Model::SurchargeFluxRelaxed | ( | std::ostream & | flux | ) | const`[protected]`

  | Sortie graphique sous forme de flux dans le format LP du probleme relaxé Paramètres:
  o | le flux à surcharger
Renvoie: le flux surchargé

void Model::UnrelaxModel | ( |  | ) |

| Nettoie le problème relaxé pour qu'il retrouve son aspect d'origine

## Documentation des fonctions amies et associées

std::ostream& operator<< | ( | std::ostream & | flux,
|  | const Model & | m
| ) | `[friend]`

  | Surcharge de l'operateur de flux Paramètres:
  flux | le flux à surcharger
  m | le modele à afficher
Renvoie: Le flux surchargé

La documentation associée à cette classe a été générée à partir des fichiers suivants :

- Model.h
- Model.cpp