apis/examples_matlab_control/transport12_8m_source.html

function transport12(varargin)


    % check workspace info from arguments

    if nargin > 0

        wsInfo = gams.control.WorkspaceInfo();

        wsInfo.systemDirectory = varargin{1};

        ws = gams.control.Workspace(wsInfo);

    else

        ws = gams.control.Workspace();

    end


    model = {

    'Sets                                                                '

    '     i   canning plants   / seattle, san-diego /                    '

    '     j   markets          / new-york, chicago, topeka / ;           '

    '                                                                    '

    'Parameters                                                          '

    '                                                                    '

    '     a(i)  capacity of plant i in cases                             '

    '       /    seattle     350                                         '

    '            san-diego   600  /                                      '

    '                                                                    '

    '     b(j)  demand at market j in cases                              '

    '       /    new-york    325                                         '

    '            chicago     300                                         '

    '            topeka      275  / ;                                    '

    '                                                                    '

    'Table d(i,j)  distance in thousands of miles                        '

    '                  new-york       chicago      topeka                '

    '    seattle          2.5           1.7          1.8                 '

    '    san-diego        2.5           1.8          1.4  ;              '

    '                                                                    '

    'Scalar f      freight in dollars per case per thousand miles  /90/ ;'

    'Scalar bmult  demand multiplier /1/;                                '

    '                                                                    '

    'Parameter c(i,j)  transport cost in thousands of dollars per case ; '

    '                                                                    '

    '          c(i,j) = f * d(i,j) / 1000 ;                              '

    '                                                                    '

    'Variables                                                           '

    '     x(i,j)  shipment quantities in cases                           '

    '     z       total transportation costs in thousands of dollars ;   '

    '                                                                    '

    'Positive Variable x ;                                               '

    '                                                                    '

    'Equations                                                           '

    '     cost        define objective function                          '

    '     supply(i)   observe supply limit at plant i                    '

    '     demand(j)   satisfy demand at market j ;                       '

    '                                                                    '

    'cost ..        z  =e=  sum((i,j), c(i,j)*x(i,j)) ;                  '

    '                                                                    '

    'supply(i) ..   sum(j, x(i,j))  =l=  a(i) ;                          '

    '                                                                    '

    'demand(j) ..   sum(i, x(i,j))  =g=  bmult*b(j) ;                    '

    '                                                                    '

    'Model transport /all/ ;                                             '

    '                                                                    '};

    model = sprintf('%s\n', model{:});


    % initialize a checkpont by running a job

    cp = ws.addCheckpoint();

    t12 = ws.addJobFromString(model);

    t12.run(cp);


    bmultlist = [0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3];


    % create a ModelInstance and solve it multiple times with different scalar bmult

    mi = cp.addModelInstance();

    db1 = ws.addDatabase();

    scen1 = db1.addSet('scen', 1, '');

    bmult = db1.addParameter('bmultlist', '', scen1);

    zscen1 = db1.addParameter('zscen', '', scen1);


    for i = 1:numel(bmultlist)

        rec = bmult.addRecord(sprintf('s%d', i));

        rec.value = bmultlist(i);

        scen1.addRecord(sprintf('s%d', i));

    end


    dict = db1.addSet('dict', 3, '');

    dict.addRecord(scen1.name, 'scenario', '');

    dict.addRecord('bmult', 'param', bmult.name);

    dict.addRecord('z', 'level', zscen1.name);


    GUSSCall(dict, mi, 'transport use lp min z', [], [], []);


    for rec = db1.getParameter(zscen1.name).records;

        fprintf('%s obj: %g\n', rec{1}.key(1), rec{1}.value);

    end


    mi2 = cp.addModelInstance();

    db2 = ws.addDatabase();

    scen2 = db2.addSet('scen', 1, '');

    zscen2 = db2.addParameter('zscen', '', scen2);

    xup = db2.addParameter('xup', 3, '');


    for k = 1:4

        for i = t12.outDB.getSet('i').records

            for j = t12.outDB.getSet('j').records

                rec = xup.addRecord(sprintf('s%d', k), i{1}.key(1), j{1}.key(1));

                rec.value = k;

            end

        end

        scen2.addRecord(sprintf('s%d', k));

    end


    dict2 = db2.addSet('dict', 3, '');

    dict2.addRecord({scen2.name, 'scenario', ''});

    dict2.addRecord({'x', 'lower', xup.name});

    dict2.addRecord({'z', 'level', zscen2.name});


    GUSSCall(dict2, mi2, 'transport use lp min z', [], [], gams.control.PrintStream());


    for rec = db2.getParameter(zscen2.name).records;

        fprintf('%s obj: %g\n', rec{1}.key(1), rec{1}.value);

    end

end


function GUSSCall(dict, mi, solveStatement, opt, miOpt, output)


    modifierList = {};

    if (dict.dimension ~= 3)

        error('Dict needs to be 3-dimensional');

    end


    scenName = dict.getFirstRecord(' ', 'scenario', ' ').key(1);

    scenSymbol = dict.database.getSet(scenName);


    for rec = dict.records

        keys = rec{1}.keys;

        key1 = lower(keys{2});

        if strcmp(key1, 'scenario')

            continue;

        end


        switch key1

            case {'param', 'lower', 'upper', 'fixed'}

                modifierDim = dict.database.getParameter(keys{3}).dimension - scenSymbol.dimension;

                if modifierDim < 0

                    error('Dimension of %s too small', keys{3});

                end

            case {'level', 'marginal'}

            otherwise

                error('Cannot handle UpdateAction %s', keys{2});

        end


        switch key1

            case {'lower', 'upper', 'fixed'}

                try

                    modifierVar = dict.database.getVariable(keys{1});

                catch

                    modifierVar = mi.syncDB.addVariable(keys{1}, modifierDim, gams.control.globals.VarType.FREE, '');

                end

            case {'level', 'marginal'}

                % Check that parameter exists in Database, will throw an exception if not

                dict.database.getParameter(keys{3});

        end


        switch key1

            case 'param'

                mod = gams.control.Modifier(mi.syncDB.addParameter(keys{1}, modifierDim, ''));

            case 'lower'

                mod = gams.control.Modifier(modifierVar, gams.control.globals.UpdateAction.LOWER, ...

                    mi.syncDB.addParameter(keys{3}, modifierDim, ''));

            case 'upper'

                mod = gams.control.Modifier(modifierVar, gams.control.globals.UpdateAction.UPPER, ...

                    mi.syncDB.addParameter(keys{3}, modifierDim, ''));

            case 'fixed'

                mod = gams.control.Modifier(modifierVar, gams.control.globals.UpdateAction.FIXED, ...

                    mi.syncDB.addParameter(keys{3}, modifierDim, ''));

        end


        switch key1

            case {'param', 'lower', 'upper', 'fixed'}

                param = dict.database.getParameter(keys{3});

                modifierList{end+1} = {mod, param};

        end

    end


    mods = {};

    for i = 1:numel(modifierList)

        if isa(modifierList{i}{1}, 'gams.control.Modifier')

            mods{end+1} = modifierList{i}{1};

        end

    end


    if isempty(opt)

        mi.instantiate(solveStatement, mods);

    else

        mi.instantiate(solveStatement, opt, mods);

    end


    outList = {};


    for s = scenSymbol.records

        for i = 1:numel(modifierList)

            m = modifierList{i}{1};

            pscen = modifierList{i}{2};


            p = m.dataSymbol;

            if isempty(p)

                p = m.gamsSymbol;

            end

            p.clear();


            filter = cell(1, pscen.dimension);

            for i = 1:scenSymbol.dimension

                filter{i} = s{1}.key(i);

            end

            for i = scenSymbol.dimension+1:pscen.dimension

                filter{i} = ' ';

            end


            try

                rec = pscen.getFirstRecord(filter);

            catch

                continue;

            end


            while true

                myKeys = cell(1, p.dimension);

                for i = 1:p.dimension

                    myKeys{i} = rec.key(scenSymbol.dimension+i);

                end

                r = p.addRecord(myKeys);

                r.value = rec.value;

                if ~rec.moveNext()

                    break;

                end

            end

        end


        if isempty(output) && isempty(miOpt)

            mi.solve(gams.control.globals.SymbolUpdateType.BASECASE);

        elseif isempty(miOpt)

            mi.solve(gams.control.globals.SymbolUpdateType.BASECASE, output);

        else

            mi.solve(gams.control.globals.SymbolUpdateType.BASECASE, output, miOpt);

        end

        if numel(outList) == 0

            for rec = dict.records

                key = lower(rec{1}.key(2));


                switch key

                    case {'level', 'marginal'}

                        sym = mi.syncDB.getSymbol(rec{1}.key(1));

                        param = dict.database.getParameter(rec{1}.key(3));

                        str = lower(rec{1}.key(2));

                        outList{end+1} = {sym, param, str};

                end

            end

        end


        for i = 1:numel(outList)

            symbol = outList{i}{1};

            param = outList{i}{2};

            str = outList{i}{3};

            myKeys = cell(1, scenSymbol.dimension + numel(symbol.getFirstRecord().keys));

            for j = 1:scenSymbol.dimension

                myKeys{j} = s{1}.key(j);

            end


            if strcmp(str, 'level') && (isa(symbol, 'gams.control.Variable') || isa(symbol, 'gams.control.Equation'))

                for rec = symbol.records

                    for j = 1:numel(rec{1}.keys)

                        myKeys(scenSymbol.dimension + j) = s{1}.key(j);

                    end

                    r = param.addRecord(myKeys);

                    r.value = rec{1}.level;

                end

            elseif strcmp(str, 'marginal') && (isa(symbol, 'gams.control.Variable') || isa(symbol, 'gams.control.Equation'))

                for rec = symbol.records

                    for j = 1:numel(rec{1}.keys)

                        myKeys(scenSymbol.dimension + j) = s{1}.key(j);

                    end

                    r = param.addRecord(myKeys);

                    r.value = rec{1}.marginal;

                end

            end

        end

    end

end