function [ts, eb, sorte] = plExemples(quoi)

% fournit:
%   soit des constantes symboliques:
%      ctes=plExemples('constantes')
%
%   soit des tableaux simpliciaux, avec variables en base:
%      [ts, eb, sorte] = plExemples(n)   % pour n=1,2, ...17
%         ts tableau simplicial
%         eb indices des variables en base
%
% Voir


% Spécifique à la définition de constantes symboliques:
if strcmp(lower(quoi),'constantes'),
   % Etats d'un tableau simplicial
   ts.SOLNONADM=1;      % solution de base non admissible
   ts.SOLOPTUNI=2;      % optimum atteint (sol.optimale unique)
   ts.SOLOPTMUL=3;      % optimum atteint (sol.optimales multiples)
   ts.FCNNONBRN=4;      % fonction économique non bornée
   ts.FCNSTABLE=5;      % f.éco. stable (indices entrant/sortant définis)
   ts.FCNCROIT=6;       % f.éco. croit strictement (cas standard)
   ts.PASBASADM=7;      % pas de base admissible
   % Les textes associés
   ts.txtEtat = { ...
           'solution NON  admissible'...
          ,'optimum ! (solution unique)' ...
          ,'optimum ! (plusieurs solutions)'...
          ,'critère non borné'...
          ,'critère va rester stable'...
          ,'critère va croître'...
          ,'pas de base admissible'...
          };
   % Comment continuer
   ts.DACCORD   =  1;             %  accepter ces indices
   ts.SAISIRR   =  2;             %  saisir indice rentrant               
   ts.SAISIRRIS =  3;             %  saisir entrant/sortant
   ts.RECUL     =  4;             %  reculer de k étapes                  
   ts.BLOUDA    =  5;             %  changer pour  Bland/Dantzig                  
   ts.SANSARRET =  6;             %  dérouler sans arrêt
   ts.ABANDON   =  0;             %  abandonner                           
   ts.txtChoix = { ...
        '1: accepter ces indices' ...
        '2: saisir indice rentrant' ...
        '3: saisir entrant,sortant' ...
        '4: reculer de k étapes'    ...
        '5: changer Bland/Dantzig'  ...
        '6: dérouler sans arrêt'    ...
        '0: abandonner'             ...
        };
   return
end

if nargin==0, disp('[tabsimpl sorte enbase] = pl_simpl(quoi)'), return, end
switch quoi,
  case 17,
     ts = [ 4   6   3   1   0   0       8
            1  -9   1   0   1   0      -3
           -2  -3   5   0   0   1      -4
            2   1   1   0   0   0       0];
     eb=[4 5 6]';
     sorte = 'base non admissible';
  case 16,
     ts = [-1  -1   1   0   0      -2
            1  -1   0   1   0       1
            0  -1   0   0   1      -3
            2   1   0   0   0       0];
     eb=[3 4 5]';
     sorte = 'bases non admissible';
  case 15,
      ts = [1  0  0  1  0  0  0  0     2
            0  1  0  0  1  0  0  0     5
            0  0  1  0  0  1  0  0     3
           45 40 36  0  0  0  1  0   360
            9 10 11  0  0  0  0  1    90
            4  5  6  0  0  0  0  0     0];
     eb=[4 5 6 7 8]';
     sorte = 'Cas standard';
  case 14,
     ts = [ 1  0  0  1  0  0  0   100
            0  1  0  0  1  0  0    50
            0  0  1  0  0  1  0   150
            3  6  2  0  0  0  1   675
            4 12  3  0  0  0  0     0];
     eb=[4 5 6 7]';
     sorte = 'Cas standard';
  case 13,
      ts = [1/4  -60 -1/25  9  1  0  0     0
            1/2  -90 -1/50  3  0  1  0     0
              0    0     1  0  0  0  1     1
            3/4 -150  1/50 -6  0  0  0     0];
     eb=[5 6 7]';
     sorte = 'Cas cycle (Dantzig)';
  case 12,
     ts = [ 2  -1   1   0   0   0       6
            1  -1   0   1   0   0       2
            1   0   0   0   1   0       4
            4  -1   0   0   0   1      14
            2   3   0   0   0   0       0];
     eb=[3 4 5 6]';
     sorte = 'td3, exo 3';
  case 11,
     ts = [ 3   3   1   0   4   0       0
            2   2   0   0   3   1       1
            0   5   0   1   2   0       4
            8  -4   0   0   1   0      -2];
     eb=[3 6 4]';
     sorte = 'td3, exo 2.6';
  case 10,
     ts = [ 1   2   0   5   0   3      10
            0  -4   0   3   1   6       2
            0   5   1   4   0   5       3
            0  -4   0  -2   0   0     -20];
     eb=[1 5 3]';
     sorte = 'td3, exo 2.5';
  case 9,
     ts = [ 5   0   0   1   4   1       1
           -3   0   1  -7   5   0      14
            2   1   0   8   2   0       8
           -8   0  -1   3   2   0      -4];
     eb=[6 3 2]';
     sorte = 'td3, exo 2.4';
  case 8,
     ts = [ 4   7   0   0   1   4       4
            2   8   0   1   0   3       0
           -2   9   1   0   0   2       0
           -5   2   0   0   0   5      -3];
     eb=[5 4 3]';
     sorte = 'td3, exo 2.3';
  case 7,
     ts = [ 0  -6   0 -3/2   -1   1       5
            1   4   0   -1    1   0       4
            0   2   1   -3   -2   0       2
            0   0   0    2 -3/2   0     -12];
     eb=[6 1 3]';
     sorte = 'td3, exo 2.2';
  case 6,
     ts = [ 1   4    1    0    3   0       5
            0  -2    2    1    5   0       4
            0   7  2/3    0    8   1       2
            0 -10    5    0   -3   0     -23];
     eb=[1 4 6]';
     sorte = 'td3, exo 2.1';
  case 5,
     ts = [ 0   1   0  1/4 -1/4       0
            0   0   1    0    1       4
            1   0   0    2    4       0
            0   0   0  1/4 -3/4      -9];
     eb=[2 3 1]';
     sorte = '? Dégénéré(fonction stable)';
  case 4,
     ts = [ 1  6  1  0      2
            0  2  3  1      3
            0  3 -1  0     -5];
     eb=[1 4]';
     sorte = '? Départ';
  case 3,
     ts = [ 1   0  -2  -3  -4/3   0      8/3
            0   0   0  -3  -5/3   1     34/3
            0   1  -4  -4  -7/3   0      5/3
            0   0 -20  -7 -13/3   0    -28/3];
     eb=[1 6 2]';
     sorte = '? Optimum atteint';
  case 2,
     ts = [ 0  0  1  1     -1
            1  1  0  1      1
           -3  0  0 -8     -2];
     eb=[3 2]';
     sorte = '? Pas admissible';
  case 1,
     ts = [ 1 -1  1  0     0
            0 -2  3  1     3
            0  5 -1  0    -1];
     eb=[1 4]';
     sorte = '? Polytope non borné';
 otherwise
end


% fonctions


% ts= plExemples(1);