Modelib: Expr class Reference

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

# Référence de la classe Expr

Classe representant les expressions linéaires. Plus de détails...

`#include <Expr.h>`

Liste de tous les membres

## Membres publics
| Expr (const NumVar &numVar)
| Expr (float)
| Expr (double)
| Expr (int)
| Expr (unsigned)
| Expr (const Num &num)
| Expr (const Num &num, const NumVar &numVar)
| Expr (const Num &num, const NumVar &numVar, const LagrangianParam &mult)
| Expr (const Expr &_expr)
Expr & | operator= (const Expr &_expr)
Expr & | operator+= (const Expr &)
Expr & | operator-= (const Expr &)
Expr & | operator *= (const Num &)
Expr & | ASS (const Num &num, const NumVar &numVar)
Expr & | ASS (const Num &num, const NumVar &numVar, const LagrangianParam &mult)
unsigned | Size ()
bool | IsNum ()
bool | IsVar ()
float | GetConstant (bool avecLagrangianParam=true) const
float | Evalue (bool avecLagrangianParam=true) const
## Membres protégés
Expr & | operator+= (const ExprNode &_node)
void | Simplify (bool AvecLagrangianParam=false, bool SansConstantes=false)
## Attributs Protégés
bool | isSimplified
bool | isParametric
bool | sansConstantes
## Amis (friends)
class | Model
std::ostream & | operator<< (std::ostream &flux, const Expr &expr)
std::ostream & | operator<< (std::ostream &o, const Model &m)

## Description détaillée

Classe representant les expressions linéaires.

Elle va etre utilisée pour décire la fonction objectif, les containtes et les bornes.

- Elle est constitué d'une liste de classe "ExprNode".
- L'operateur operator+=(const ExprNode & _node) permet la construction iterative de ces expressions.
- Une expressions peut être construite à partir de Num et de NumVar et peut être définir par l'ajout d'une expressions à elle avec différents opérateurs
- Elle est déclaré friend avec la classe Model car elle n'a volontairement pas de geters, de seters ou d'iterateurs sur la liste d'ExprNode qui est privée. La classe Model est ainsi la seule qui peut modifié sa strcuture interne. Pour les même raisons l'opérateur de flux << à besoin d'être déclarer friend.
- Les expressions étant simplifiées a chaque fois, il serait peut-être bon de rajouter une fonction qui permet de construire une fonction sans la simplifier

## Documentation des contructeurs et destructeurs

Expr::Expr | ( | const NumVar & | numVar | ) |

  | Constructeurs à partir d'une seule variable Paramètres:
  numVar | La variable qui constituera l'expression

Expr::Expr | ( | float | f | ) |

  | Constructeurs à partir d'une constante réelle Paramètres:
  f | La constante réelle qui constituera l'expression

Expr::Expr | ( | double | f | ) |

  | Constructeurs à partir d'une constante réelle Paramètres:
  double | La constante réelle qui constituera l'expression

Expr::Expr | ( | int | i | ) |

  | Constructeurs à partir d'une constante entière Paramètres:
  i | La constante entière qui constituera l'expression

Expr::Expr | ( | unsigned | i | ) |

  | Constructeurs à partir d'une constante entière non signée Paramètres:
  i | La constante entière qui constituera l'expression

Expr::Expr | ( | const Num & | num | ) |

  | Constructeurs à partir d'une constante Paramètres:
  num | La constante qui constituera l'expression

Expr::Expr | ( | const Num & | num,
|  | const NumVar & | numVar
| ) |

  | Constructeurs à partir d'une constante et d'une variable Le produit constante qui constituera l'expression Paramètres:
  num | La constante
  numVar | La variable

Expr::Expr | ( | const Num & | num,
|  | const NumVar & | numVar,
|  | const LagrangianParam & | mult
| ) |

  | Constructeurs à partir d'une constante et de deux variable Le produit constante qui constituera l'expression Paramètres:
  num | La constante
  numVar | La variable
  numVar | La variable optionnelle

Expr::Expr | ( | const Expr & | _expr | ) | `[inline]`

| Constructeur de copie

## Documentation des méthodes

Expr & Expr::ASS | ( | const Num & | num,
|  | const NumVar & | numVar,
|  | const LagrangianParam & | mult
| ) |

  | ASS: ajout sans simplification Paramètres:
  num |
  numVar |
Renvoie: L'Expr {expr=expr+num*numVar} non simplifiée

Expr & Expr::ASS | ( | const Num & | num,
|  | const NumVar & | numVar
| ) |

  | ASS: ajout sans simplification Paramètres:
  num |
  numVar |
Renvoie: L'Expr {expr=expr+num*numVar} non simplifiée

float Expr::Evalue | ( | bool | avecLagrangianParam = true | ) | const

  | Permet de récuperer la valeur de l'expression Paramètres:
  avecLagrangianParam | permet de tenir compte de la présence du multiplicateur de Lagrange
Renvoie: la valeur de l'expression

float Expr::GetConstant | ( | bool | avecLagrangianParam = true | ) | const

  | Permet de récuperer la partie constante de l'expression Paramètres:
  avecLagrangianParam | permet de tenir compte de la présence du multiplicateur de Lagrange
Renvoie: la constante de l'expression

bool Expr::IsNum | ( |  | ) |

| Permet de tester si l'expression est constituée seulement d'une constante Fonction utilisé dans pour dans Constrain::CheckIfIsBound() Renvoie: vrai si l'expression se reduit à une constante

bool Expr::IsVar | ( |  | ) |

| Permet de tester si l'expression est constituée seulement d'une variable Fonction utilisé dans pour dans Constrain::CheckIfIsBound() Renvoie: vrai si l'expression se reduit à une variable

Expr & Expr::operator *= | ( | const Num & | a | ) |

  | Multiplie une expression par une constante Paramètres:
  a |
Renvoie: L'Expr {expr=a*this} non simplifiée

Expr & Expr::operator+= | ( | const Expr & | _expr | ) |

  | Additionne une expression avec l'expression this Paramètres:
  _expr |
Renvoie: L'Expr {expr=expr+_expr} non simplifiée

Expr& Expr::operator+= | ( | const ExprNode & | _node | ) | `[inline, protected]`

  | Opérateur d'ajout de node Paramètres:
  _node | un noeud de l'expression du type ExprNode
Renvoie: une reférence pour pouvoir enchainer les opéraeurs +=

Expr & Expr::operator-= | ( | const Expr & | _expr | ) |

  | Soustrait une expression avec l'expression this Paramètres:
  _expr |
Renvoie: L'Expr {expr=expr-_expr} non isSimplified

Expr& Expr::operator= | ( | const Expr & | _expr | ) | `[inline]`

| Opérateur de recopie

void Expr::Simplify | ( | bool | avecLagrangianParam = false,
|  | bool | sansConstante = false
| ) | `[protected]`

  | Fonction Simplify met l'expr sous la forme a1*x1+...+an*xn tel que les xi n'apparaissent qu'une fois si ai est non nul. Paramètres:
  avecLagrangianParam | permet de tenir compte des multiplicateurs de Lagrange
  sansConstante | permet de ne pas tenir compte des constantes

unsigned Expr::Size | ( |  | ) | `[inline]`

| Permet de connaitre la taille d'une expression Renvoie: Le nombre de bloc élementaire composant l'expression

## Documentation des fonctions amies et associées

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

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

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

  | Operateur de surcharge de flux << On simplifie la fonction avant affichage Paramètres:
  flux | Flux à surcharger
  expr | L'Expr à afficher
Renvoie: le flux surchargé

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

- Expr.h
- Expr.cpp