---

algorithms/SClassification.h

Go to the documentation of this file.

/* #start# ***********************************************************

           Scheduling Simulator
        Lehrstuhl f"ur Effiziente Algorithmen
           Technische Universit"at M"unchen

 File    : $Id: SClassification.h,v 1.5 2003/03/21 15:47:05 taeubig Exp $

 Purpose : this class implements the usual classification scheme for
           scheduling algorithms and problems. classifications can be
           compared in order to find out whether an algorithm and a
           problem instance are compatible.

 RCS-Log:
 $Log: SClassification.h,v $
 Revision 1.5  2003/03/21 15:47:05  taeubig
 merge with source from Bertolt

 Revision 1.4  2003/01/24 10:04:46  hall
 brdCast stuff

 Revision 1.3  2003/01/08 18:57:10  meierb
 added randomized release times

 Revision 1.4  2003/01/08 15:29:06  meierb
 schlcht gelaufen mit der Pruefung

 Revision 1.3  2003/01/06 22:27:47  meierb
 blablabla

 Revision 1.2  2002/12/16 23:32:09  meierb
 *** empty log message ***

 Revision 1.1.1.1  2002/12/02 22:26:19  meierb
 my_schedule

 Revision 1.1  2002/08/29 12:59:58  taeubig
 Added the sources

 Revision 1.19  2000/12/06 11:35:09  taeubig
 Cosmetics (seperate->separate)

 Revision 1.18  2000/12/04 16:08:31  taeubig
 Incremented size of _egArray

 Revision 1.17  2000/07/23 18:57:47  mayerh
 added method to seperate input-string

 Revision 1.16  2000/07/19 19:59:19  mayerh
 added methods to get and set Job-Time Intervals

 Revision 1.15  2000/06/13 14:02:26  hall
 no real changes ...

 Revision 1.14  2000/06/09  14:08:24  schickin
 small bug in SClassification removed (static h_array is now d_array)

 Revision 1.13  2000/05/31 14:59:50  mayerh
 added static member-variables

 Revision 1.12  2000/05/24 12:21:01  taeubig
 New compiler (gcc-2.95) and new Qt (2.1)
 Replaced "list" by "leda_list" etc.

 Revision 1.11  2000/05/09 10:36:06  taeubig
 Added const declarations

 Revision 1.10  2000/05/07 22:27:31  taeubig
 Minor changes to avoid warnings and make it compile with gcc 2.95.2

 Revision 1.9  2000/04/19 19:57:44  mayerh
 deleted get- / setNumberOfMachines

 Revision 1.8  2000/04/14 10:01:54  mayerh
 added function setNumberOfMachines()

 Revision 1.7  2000/04/12 20:42:47  mayerh
 added attributes _descriptor, _numberOfMachines and corresponding access methods

 Revision 1.6  2000/04/05 21:00:56  mayerh
 added explicit declaration of the default-constructor (required by some compiler-versions)

 Revision 1.5  2000/03/28 13:03:05  hall
 updated Interface of SClassif and SSchedAlg.

 Revision 1.4  2000/01/12 11:31:33  zoidl
 added javadoc comments and cosmetic changes in getDescription

 Revision 1.3  1999/08/05 08:47:45  schickin
 purpose of important classes noted in the header-files

 Revision 1.2  1999/01/29 10:03:25  schickin
 Project-Headers added.


 * #end# ************************************************************* */

#ifndef SCLASSIFICATION_H
#define SCLASSIFICATION_H

#include <LEDA/string.h>
#include <LEDA/graph.h>
#include <LEDA/graph_alg.h>
#include <LEDA/list.h>
#include <LEDA/d_array.h>

class SClassification {
public:
  SClassification(){}
  SClassification(const leda_string &s);

  bool isGeneralizationOf(const SClassification &classif) const;
  const leda_string &getDescriptor(int i) const;
  const leda_string &toString() const;

/*
  * use the following methods to read and write the interval bounds of the
  * job finishing times(PVal*) or the release times(RVal*).
  * If the processing times depend only on one parameter(e.g. they are constant
  * or distributed exponentially) use just val1, or set both values the same.
  */

  double getPVal1() const;
  void setPVal1(double val);
  double getPVal2() const;
  void setPVal2(double val);

  double getRVal1() const;
  void setRVal1(double val);
 
private:
  static const int _intArrayLength = 6;

  static bool _boolFirstInit;
  static leda_graph _G;
  static leda_d_array<leda_string, leda_node> _ndArray[_intArrayLength];
  static leda_edge _egArray[_intArrayLength][19];

  leda_string _descriptor[_intArrayLength];
  int _numberOfMachines;
  // parameters for processing times (e.g. lower, upper, parameter)
  double _pval1;
  double _pval2;
  // parameters for release times (e.g. rate, length n)
  double _rval1;

// ----------------------------------------------------------------------
  leda_list<leda_string> separateInputString(leda_string s) {
    char tmp;
    leda_list<leda_string> lstTmp;
    int intLeft = 0, intRight = 0;

    for(int i = 0; i < s.length(); i++) {
      tmp = s[i];
      if (tmp == ',' || tmp == '|') {
        lstTmp.push(s(intLeft, intRight));
        intLeft = intRight + 2;
      }
      intRight = i;
    }
    //get last string
    lstTmp.push(s(intLeft, intRight));  
    return lstTmp;
  }

};
// ----------------------------------------------------------------------

#endif //SCLASSIFICATION_H

---