SolverHandler Klassenreferenz

Klassendiagramm für SolverHandler:

Öffentliche Methoden
void	setInstance (const Instance &data)
void	solve (SolveResult &_return, const vector< bool > &fix, const int lastBest)

Private Attribute
Instance	_data
	Server merkt sich die Daten, mit denen er durch solve() arbeiten soll. Mehr ...
glp_prob *	_lp
	Das "GLPK-Objekt" _lp, welches zum Lösen mit der GLPK-API notwendig ist. Mehr ...

Ausführliche Beschreibung

Die Klasse SolverHandler ist die Implementierung von Solver und erbt vom Solver-Interface alles notwendige, damit das thrift-Framework daraus einen Server (mit einem einzelnen "Solve"-Service) erstellen kann.

Dokumentation der Elementfunktionen

void SolverHandler::setInstance ( const Instance &  data )

inline

Diese Methode wird vom Solver-Service (= unser Worker) zur Verfügung gestellt, damit der Client (= unser Farmer) zu Anfang allen die Daten, mit denen gerechnet werden sollen, zusenden kann.

Parameter

[in]

data

Enthält die Daten im Datentyp Instance, so wie in der IDL beschreiben

Rückgabe

nichts

    {
        _data = data;
        if (_lp != nullptr) glp_delete_prob(_lp);
        _lp = glp_create_prob();
        // Ausgabe von glpk unterdrücken
        glp_term_out(GLP_OFF);

        int      N = _data._profits.size();
        int      T = _data._budgets.size();
        // "ia" ist für den Index der Zeile (Bedingung), zu der der Faktor (in ar) gehört
        int    *ia = new int[(T+1)*N +1];
        // "ja" ist für den Index der Spalte (Variable), zu der der Faktor (in ar) gehört
        int    *ja = new int[(T+1)*N +1];
        double *ar = new double[(T+1)*N +1];
        
        /* Da die GLPK-API auch für andere Programmiersprachen existert,
         * arbeitet sie mit dem Index 1 statt 0. Daher muss man bei den
         * Arrays +1 in der Größe hinzu addieren. */
        
        glp_set_obj_dir(_lp, GLP_MAX);
        /* Das T+1, kommt daher, weil zu den T vielen Budget-Grenzen noch eine
         * weitere Bedingung (untere Grenze) beigefügt wird. Mit dieser Bedingung
         * lässt sich eine Berechung frühzeitig abbrechen, falls bereits eine
         * bessere Lösung existert. */
        glp_add_rows(_lp, T+1);
        glp_add_cols(_lp, N);

        // Budgets -------------------------------------------
        for (int t=0; t < T; ++t) {
            // obere Grenze je Bedingung festlegen
            glp_set_row_bnds(_lp, t+1, GLP_UP, 0.0, _data._budgets[t]);
        }

        int qq = 1;
        for (int n=0; n < N; ++n) {
            for (int t=0; t <= T; ++t) {
                ia[qq] = t+1;
                ja[qq] = n+1;
                if (t < T) {
                    // füllen der "Kostenmatrix"
                    ar[qq] = _data._costs[t][n];
                } else {
                    /* Die letzte Bedingung enthält die Profite je Projekt, um
                     * zusammen mit einer lower Bound Bedingung eine untere
                     * Grenze für die Lösung zu definieren */
                    ar[qq] = _data._profits[n];
                }
                ++qq;
            }
            /* der Profit je Projekt ist der Faktor jeder Varible in der Gleichung,
             * die zu Optimieren ist */
            glp_set_obj_coef(_lp, n+1, _data._profits[n]);
        }
        glp_load_matrix(_lp, (T+1)*N, ia, ja, ar);
        cout << "Instance ready." << endl;
    }

void SolverHandler::solve ( SolveResult &  _return, const vector< bool > &  fix, const int  lastBest  )

inline

Diese Methode wird vom Solver-Service (= unser Worker) zur Verfügung gestellt, damit der Client (= unser Farmer) zu Anfang allen die Daten, mit denen gerechnet werden sollen, zusenden kann.

Parameter

[out]	_return	Enthält das Ergebnis der Berechnung
[in]	fix	fix enthält die Projekt-Vorbelegung
[in]	lastBest	lastBest enthält eine bisher beste Lösung und soll als untere Grenze dienen

Rückgabe

nichts; Rückgabe ist in der Referenz _return enthalten

    {
        int errCode;
        int N  = _data._profits.size();
        int T  = _data._budgets.size();
        int fi = fix.size();
        
        /* Zu den T Bedingungen eine weitere beifügen, die die
         * bisher beste Lösung als untere Grenze festlegt */
        glp_set_row_bnds(_lp, T+1, GLP_LO, lastBest, 0.0);

        for(int n=0; n < N; ++n) {
            if(n > fi-1) {
                // Die Variablen als B inäre V ariable für die Integer-Optimierung festlegen
                glp_set_col_kind(_lp, n+1, GLP_BV);
                // Für das Simplex-Verfahren die Variablengrenzen (Double Bounded) zwischen 0..1 setzen
                glp_set_col_bnds(_lp, n+1, GLP_DB, 0.0, 1.0);
            } else {
                // Variablen als "Fix" setzen, die durch Vorbelegung nicht geändert werden dürfen.
                if(fix[n] == true) {
                    glp_set_col_bnds(_lp, n+1, GLP_FX, 1.0, 1.0);
                } else {
                    glp_set_col_bnds(_lp, n+1, GLP_FX, 0.0, 0.0);
                }
            }
        }

        // initial: erstmal Simplex Verfahren (schnell!!) ======
        glp_smcp para1;
        glp_init_smcp(&para1); // default Parameter setzen
        
        errCode = glp_simplex(_lp, &para1);
        if (errCode != 0) {
            // keine bessere Loesung gefunden (-> cut)
            _return._flag = Flag::CUT;
            return;
        }
        _return._flag = Flag::OK;

        // Binaere Loesung mit Integer-Optimerung suchen ========
        glp_iocp para2;
        glp_init_iocp(&para2);
        para2.tm_lim = _data._timeoutMs; // Zeitlimit setzen

        errCode = glp_intopt(_lp, &para2);
        switch(errCode) {
            case 0:
                // ok (Ergebnis >= lastBest)
                _return._flag = Flag::OK;
                break;
            case GLP_ETMLIM:
                // nicht fertig geworden (-> neu vorbelegen)
                _return._flag = Flag::TIMEOUT;
                return;
            default:
                // keine bessere Loesung gefunden (-> cut)
                _return._flag = Flag::CUT;
                return;
        }
        
        _return._projects.resize(N);
        for (int n=0; n<N; ++n) {
            if (glp_mip_col_val(_lp, n+1) > 0)
                _return._projects[n] = true;
            else
                _return._projects[n] = false;
        }
        _return._optimum = glp_mip_obj_val(_lp);
    }

Dokumentation der Datenelemente

Instance SolverHandler::_data

private

Server merkt sich die Daten, mit denen er durch solve() arbeiten soll.

glp_prob* SolverHandler::_lp

private

Das "GLPK-Objekt" _lp, welches zum Lösen mit der GLPK-API notwendig ist.

---

Die Dokumentation für diese Klasse wurde erzeugt aufgrund der Datei:

• Worker.cpp