Lär dig matematik genom att modellera den i GAMS

Kapitel 00Kom igång

GAMS (General Algebraic Modeling System) är inte ett programmeringsspråk i vanlig mening. Det är ett modelleringsspråk: du beskriver ett matematiskt problem – mängder, data, variabler och ekvationer – och överlåter åt en lösare (solver) att hitta svaret. Det gör GAMS till ett ovanligt bra verktyg för att lära sig matematik, för du tvingas skriva problemet exakt så som det står i boken.

Så arbetar du med kursen

1. Läs kapitlen i ordning – varje kapitel bygger på det föregående.
2. Klistra in kodexemplen i en .gms-fil och kör dem. Filändelsen är alltid .gms och du kör med gams filnamn.gms.
3. Gör övningarna i kapitel 10. Facit finns bakom varje uppgift – försök först själv.
4. Använd live-labbet när du vill se hur en ändrad koefficient flyttar optimum.

Installera GAMS

GAMS är kommersiellt men har en gratis demoversion som räcker gott för allt i den här kursen. Ladda ner den från gams.com/download och installera. Vill du inte installera något kan du köra GAMS-kod gratis via NEOS Server i webbläsaren.

Programmets anatomi

Varje GAMS-program har samma fem byggstenar. Lär dig ordningen – den återkommer i varje kapitel.

* Vårt första program: räkna ut en summa
Set    i   "de tre talen"        / ett, tva, tre /;
Parameter v(i) "talens värde"   / ett 4, tva 7, tre 11 /;
Scalar   s   "summan av talen";

s = sum(i, v(i));
Display s;

Kör du det här får du utskriften s = 22.00. Ingen lösare, ingen optimering – bara ren matematik. Det är en bra början: i GAMS är en summa en summa.

Kapitel 01Mängder – matematikens index

Nästan all matematik bygger på index. I stället för att skriva x₁, x₂, x₃ skriver vi x_i, i ∈ I. I GAMS deklarerar du mängden en gång och använder den sedan som index överallt.

Deklaration och innehåll

Mängdens element listas mellan snedstreck, separerade med kommatecken eller mellanslag. Texten inom citattecken är en beskrivning som hamnar i utskrifterna och är ovärderlig när modellen växer.

Set i "grödor"      / vete, majs /;
Set j "regioner"    / nord, syd  /;

* Intervall med * eller ..  ger nord, mellan, syd automatiskt
Set k "kvartal"     / q1*q4 /;
Set t "perioder"    / 2024*2030 /;

Display i, j, k, t;

Flerdimensionella mängder (par)

En mängd behöver inte vara en lista av enskilda objekt – den kan bestå av par. Det är precis vad en tabell med tillåtna kombinationer är: (i, j) ∈ IJ.

* Vilka grödor får odlas var? Bara dessa par finns.
Set växt(i,j) "tillåtna kombinationer" /
   vete.nord, vete.syd, majs.syd /;

* Summera bara över de par som finns:
Parameter areal(i,j);
areal(i,j) = 10;
Scalar total "summan över tillåtna par";
total = sum(växt(i,j), areal(i,j));   * = 30

Alias – när samma index behövs två gånger

Vill du jämföra i med j över samma mängd (t.ex. avstånd mellan städer) behöver GAMS två namn på samma mängd. Det fixar Alias.

Set stad / Sthlm, Gbg, Malmö /;
Alias(stad, stad2);

Parameter avstånd(stad,stad2) "km";
avstånd("Sthlm","Gbg") = 470;
Display avstånd;

Mängdoperationer

Mängder kan byggas dynamiskt – ungefär som mängdlära med ∪, ∩ och ∖. Tecknet + betyder union, * snitt och - differens.

Set alla   / a, b, c, d /;
Set udda   / a, c /;
Set jamna  / b, d /;
Set union_     "alla igen"        ;
Set snitt      "gemensamma"       ;

union_(alla) = yes;          * kopiera hela mängden
snitt(udda)  = yes;
snitt(jamna) = no;           * ta bort det som finns i jamna
Display snitt;               * blir a, c

Symbolen yes/no är mängdens ”medlemskap”: ett element finns i mängden om dess värde är yes. Det gör att du kan bygga filtervillkor mitt i en modell.

Kapitel 02Parametrar, tabeller och matriser

En parameter är en talad tabell. Har den noll index är den en skalär, har den ett index är den en vektor, har den två index är den en matris. Det enda som skiljer dem åt i GAMS är hur många index du anger.

Två sätt att fylla i data

Antingen inline mellan snedstreck, eller med tilldelningssatser. Tabellformen är överlägsen när du ska läsa in en matris från en lärobok.

Set i / vete, majs /;
Set j / nord, syd  /;

* 1) Inline
Parameter p(i) "pris per ton" / vete 12, majs 9 /;

* 2) Tabell – skrivs som den ser ut i boken
Table avkastning(i,j) "ton per hektar"
        nord   syd
vete      4      2
majs      1      6;

* 3) Tilldelning rad för rad
Parameter kostnad(i);
kostnad("vete") = 3;
kostnad("majs") = 2;

Display p, avkastning, kostnad;

Data som räknas fram

Parametrar behöver inte vara givna – de kan beräknas med matematiska uttryck. Här blir en kostnad som är proportionell mot avkastningen:

Parameter intakt(i,j) "intäkt per hektar";
intakt(i,j) = p(i) * avkastning(i,j);

Scalar snitt "genomsnittlig intäkt";
snitt = sum(i, sum(j, intakt(i,j))) / card(i) / card(j);

Parameter andel(i,j) "hur stor del av totalen";
andel(i,j) = intakt(i,j) / sum((i,j), intakt(i,j));   * notera dubbelsumman

Funktionerna card(mängd) ger antalet element – matematikens |I|. Den är ovärderlig för medelvärden.

Vanliga matematiska funktioner

Kapitel 03Summor, produkter och villkor

Sättet du skriver Σ på i GAMS är kursens kanske viktigaste enskilda färdighet. Formen är alltid densamma:

Tre saker att lägga märke till: indexmängden skrivs utan∈, indexet får inte förekomma fritt i uttrycket efter kommatecknet, och multiplikation skrivs med * – GAMS gissar aldrig.

Dubbelsummor

Σ_i Σ_j a_ij skrivs antingen nästlat eller med två index i samma summa. Den senare formen är kortare och vanligast:

Scalar s1, s2;
s1 = sum(i, sum(j, a(i,j)));   * nästlad
s2 = sum((i,j), a(i,j));       * kompakt – samma resultat

* Radsummor: index j summeras bort, i blir kvar
Parameter radsumma(i);
radsumma(i) = sum(j, a(i,j));

* Kolumnsummor: omvänt
Parameter kolsumma(j);
kolsumma(j) = sum(i, a(i,j));

Villkor med $

Dollartecknet är GAMS ”så att”-konstruktion. sum(i$villkor(i), x(i)) betyder Σ över de i där villkoret är sant.

* Summera bara positiva värden
Scalar pos;
pos = sum(i$ (v(i) > 0), v(i));

* Villkor på två index samtidigt
Parameter dyrt(i,j);
dyrt(i,j) = avkastning(i,j) $ (p(i) > 10);

* Tilldela bara där mängden är definierad – undviker division med noll
Parameter kvot(i,j);
kvot(i,j) $ avkastning(i,j) = intakt(i,j) / avkastning(i,j);

Ett komplett exempel: viktat medelvärde

Låt w_i vara vikter som summerar till 1 och r_i avkastningar. Då är portföljens avkastning Σ w_i r_i, och variansen kräver en dubbelsumma med kovariansmatrisen Σ_iΣ_j w_i w_j σ_ij:

Set i "tillgångar" / aktie, obligation, guld /;

Parameter r(i)   "förväntad avkastning" / aktie 0.08, obligation 0.03, guld 0.05 /;
Parameter w(i)   "portföljvikt";
w(i) = 1/card(i);                     * likaviktad portfölj

Parameter sigma(i,j) "kovarians (förenklad)";
sigma(i,i) = 0.04;
sigma(i,j) $ (not sameas(i,j)) = 0.005;

Scalar mu     "portföljavkastning";
Scalar varians "portföljvarians";

mu     = sum(i, w(i)*r(i));
varians = sum((i,j), w(i)*w(j)*sigma(i,j));

Display mu, varians;

sameas(i,j) är en inbyggd funktion som är sann när de två indexen pekar på samma element. Den används flitigt för diagonaler.

Kapitel 04Optimering: linjär programmering

Nu blir det matematik på riktigt. Ett linjärt programmeringsproblem (LP) består av en målfunktion och ett antal bivillkor – allt linjärt. Vi tar ett klassiskt produktionsplaneringsproblem och följer det från lärobokens formler till GAMS-kod.

Steg 1 – variabler

De obekanta blir Variable. Skriver du Positive Variable får du x ≥ 0 gratis; det motsvarar x.lo = 0.

Positive Variable x "antal enheter produkt X";
Positive Variable y "antal enheter produkt Y";
Variable          z "total vinst";

Steg 2 – ekvationer

I GAMS kallas både målfunktionen och bivillkoren för Equation. Skillnaden ligger bara i relationstecknet:

Equation obj  "målfunktion";
Equation maskin "maskintid";
Equation arbeta "arbetstid";

obj..    z =e= 3*x + 2*y;
maskin.. x + 2*y =l= 8;
arbeta.. 3*x + y =l= 9;

Steg 3 – modell och lösning

Model verkstad / all /;                 * 'all' = alla ekvationer ingår
Solve verkstad using lp maximizing z;

Display x.l, y.l, z.l;

Resultatet blir x = 2, y = 3, z = 12. Kontrollera gärna för hand: maskintid 2 + 6 = 8 (fullt utnyttjad), arbetstid 6 + 3 = 9 (också fullt utnyttjad).

Samma problem, men med mängder

Det stora värdet av GAMS kommer först när du generaliserar. Byt ut x, y mot x_p över produkter p, och resurserna mot r:

Set p "produkter"      / X, Y /;
Set r "resurser"       / maskin, arbete /;

Parameter vinst(p)     / X 3, Y 2 /;
Parameter kapacitet(r) / maskin 8, arbete 9 /;
Table atgang(r,p) "åtgång per enhet"
           X    Y
maskin     1    2
arbete     3    1;

Positive Variable x(p) "producerad mängd";
Variable          z    "total vinst";

Equation obj "maximera vinsten";
Equation res(r) "resursbegränsning";

obj..    z =e= sum(p, vinst(p)*x(p));
res(r).. sum(p, atgang(r,p)*x(p)) =l= kapacitet(r);

Model verkstad2 / all /;
Solve verkstad2 using lp maximizing z;
Display x.l, z.l;

Exakt samma svar – men nu räcker det att lägga till en rad i tabellen för att modellen ska hantera en tredje produkt. Det är den enda ändringen. Jämför med att skriva om alla formler för hand.

Målfunktioner som minimeras

Vill du minimera i stället skriver du bara minimizing. Ett transportproblem – minimera kostnaden för att frakta varor från lager i till kunder j – är ett typexempel:

Set i "lager"   / l1, l2 /;
Set j "kunder"  / k1, k2, k3 /;

Parameter tillgang(i) "utbud"   / l1 20, l2 30 /;
Parameter behov(j)    "efterfrågan" / k1 15, k2 20, k3 15 /;
Table kostnad(i,j) "kr per enhet"
       k1   k2   k3
l1      4    6    9
l2      5    3    7;

Positive Variable flode(i,j) "transporterad mängd";
Variable          tot       "totalkostnad";

Equation mal;
Equation utbud(i);
Equation efterfragan(j);

mal..              tot =e= sum((i,j), kostnad(i,j)*flode(i,j));
utbud(i)..         sum(j, flode(i,j)) =l= tillgang(i);
efterfragan(j)..   sum(i, flode(i,j)) =g= behov(j);

Model transport / all /;
Solve transport using lp minimizing tot;
Display flode.l, tot.l;

Observera symmetrin: rader i tabellen blir i-villkor, kolumner blir j-villkor. Att kunna läsa av en tabell så här är halva arbetet med all modellering.

Kapitel 05Live-labb: flytta optimum själv

Ändra koefficienterna nedan och se hur det tillåtna området, optimum och den genererade GAMS-koden förändras direkt. Det här är det snabbaste sättet att bygga intuition för vad ett bivillkor egentligen gör.

GAMS-kod för exakt det problem du ser

--

Kapitel 06Linjär algebra i GAMS

GAMS är byggt för att skriva matriser och vektorer utan att du behöver tänka på loopar. Allt du gör med index görs ”på en gång” för alla element.

Skalärprodukt och norm

Set i / 1*4 /;
Parameter u(i) / 1 1, 2 2, 3 3, 4 4 /;
Parameter v(i) / 1 2, 2 0, 3 -1, 4 5 /;

Scalar dot, normu, vinkel;
dot    = sum(i, u(i)*v(i));
normu  = sqrt(sum(i, u(i)*u(i)));

* Vinkeln mellan vektorerna: cos θ = u·v / (‖u‖‖v‖)
vinkel = arccos( dot / (normu * sqrt(sum(i, v(i)*v(i)))) );
Display dot, normu, vinkel;

Matrismultiplikation

C = A·B där A är m×n och B är n×p kräver ett summationsindex över n. Eftersom n-mängden redan används som index måste vi skapa ett alias:

Set m / r1*r2 /;
Set n / c1*c3 /;
Set p / q1*q2 /;
Alias(n, n2);                       * två namn på samma mängd

Parameter A(m,n) / r1.c1 1, r1.c2 2, r1.c3 3
                   r2.c1 4, r2.c2 5, r2.c3 6 /;
Parameter B(n,p) / c1.q1 1, c1.q2 0
                   c2.q1 2, c2.q2 1
                   c3.q1 0, c3.q2 3 /;

Parameter C(m,p) "produkten";
C(m,p) = sum(n, A(m,n)*B(n,p));

Display C;

Linjära ekvationssystem

Att lösa Ax = b är i GAMS samma sak som att lösa ekvationssystemet – det finns ingen speciell matrisoperator. Du skriver ut systemet rad för rad, med summan över kolumnindex:

Set i / 1*3 /;
Alias(i, j);

Table A(i,j) "koefficientmatris"
        1    2    3
1       2   -1    0
2       1    3    1
3       0    1    2;

Parameter b(i) / 1 5, 2 10, 3 7 /;

Variable x(i) "de obekanta";
Equation ekv(i) "rad i av systemet";
Equation dummy  "konstgjord målfunktion";

ekv(i)..   sum(j, A(i,j)*x(j)) =e= b(i);
dummy..    obj =e= 0;               * krävs: GAMS vill optimera något

Model system / all /;
Solve system using lp minimizing obj;
Display x.l;

Knepet med en konstgjord målfunktion som är noll gör att lösaren bara letar efter en tillåten punkt – vilken som helst – och den punkten är systemets lösning. Ett alternativ är att deklarera Solve system using cns; (constraint satisfaction), men LP-varianten fungerar överallt.

Matrisuttryck som blir optimering

Många centrala problem i linjär algebra är optimeringsproblem i förklädnad. Minstakvadratlösningen min ‖Ax − b‖² skrivs direkt:

Variable x(j);
Variable avvikelse(i);
Variable sumkvad;

Equation definiera(i);
Equation mal;

definiera(i).. avvikelse(i) =e= sum(j, A(i,j)*x(j)) - b(i);
mal..         sumkvad =e= sum(i, avvikelse(i)*avvikelse(i));

Model minstakvadrat / all /;
Solve minstakvadrat using nlp minimizing sumkvad;   * nlp – inte lp!

Här blir x fri (både positiva och negativa värden är tillåtna), och problemet är kvadratiskt – därför nlp.

Kapitel 07Heltal och logik

Många matematiska beslut är diskreta: man väljer ett objekt eller inte, man producerar hela enheter. Då byter du variabeltyp och lösaren gör ett enormt sökarbete åt dig.

Kappsäcksproblemet

Välj föremål så att värdet maximeras utan att vikten överstiger kapaciteten: max Σ v_py_p då Σ w_py_p ≤ K, y_p ∈ {0,1}.

Set p "föremål" / karta, kamera, talt, bok, vin /;

Parameter varde(p) / karta 10, kamera 13, talt 8, bok 6, vin 12 /;
Parameter vikt(p)  / karta 2,  kamera 5,  talt 4, bok 3, vin 6  /;
Scalar    kapacitet / 15 /;

Binary Variable y(p) "1 om föremålet packas";
Variable        z    "totalt värde";

Equation mal, kap;
mal.. z =e= sum(p, varde(p)*y(p));
kap.. sum(p, vikt(p)*y(p)) =l= kapacitet;

Model ryggsack / all /;
Solve ryggsack using mip maximizing z;
Display y.l, z.l;

Tillordningsproblem – permutationer som optimering

Att hitta den bästa kopplingen mellan personer i och uppgifter j är ett permutationsproblem. Varje person får exakt en uppgift, varje uppgift exakt en person:

Set i "personer" / anna, bo, cissi /;
Set j "uppgifter" / disk, tvatt, stryk /;

Table kostnad(i,j) "tidsåtgång i minuter"
        disk  tvatt  stryk
anna      20     12     30
bo        25     18     20
cissi     15     25     22;

Binary Variable x(i,j) "1 om i gör j";
Variable        tot    "total tid";

Equation mal;
Equation varje_person(i);
Equation varje_uppgift(j);

mal..                tot =e= sum((i,j), kostnad(i,j)*x(i,j));
varje_person(i)..    sum(j, x(i,j)) =e= 1;
varje_uppgift(j)..   sum(i, x(i,j)) =e= 1;

Model schema / all /;
Solve schema using mip minimizing tot;
Display x.l, tot.l;

Antalet möjliga scheman är 3! = 6, och GAMS provar dem utan att du skriver en enda loop. Med 20 personer är antalet 20! ≈ 2,4·10¹⁸ – ändå löses problemet på bråkdelar av en sekund, tack vare branch-and-bound.

Logiska villkor med binära variabler

”Om vi producerar x måste vi starta maskinen (y = 1)” är inte linjärt – men det går att skriva linjärt med en stor konstant M:

* x > 0  =>  y = 1      skrivs som   x <= M*y
Equation koppling;
Scalar M / 1000 /;
koppling.. x =l= M*y;

Heltalsvariabler med gränser

Integer Variable n "antal maskiner";
n.lo = 1;      * minst 1
n.up = 5;      * högst 5
n.prior = 2;   * lösaren prioriterar denna vid branching

Kapitel 08Tolka lösningen – där matematiken blir insikt

Att få ett tal är inte samma sak som att förstå problemet. GAMS ger dig tre sorters information om varje variabel och ekvation: värde, gränser och marginalvärde.

Skuggpriset – kapitlets viktigaste begrepp

I verkstadsmodellen: maskin.m talar om hur mycket målfunktionen ökar om vi får en extra enhet maskintid. Är den 1,5 betyder det att z ökar med 1,5 per extra maskintimme – alltså är det värt upp till 1,5 kr att köpa en extra timme.

Display z.l;        * optimalt värde
Display x.l, y.l;   * optimala nivåer
Display maskin.m;   * skuggpris för maskintid
Display maskin.slack;   * hur mycket kapacitet som blev över

Läs lösningsrapporten

Varje Solve skriver en rapport. Kontrollera alltid två rader innan du tror på siffrorna:

• SOLVER STATUS – att lösaren själv fungerade. 1 Normal Completion är bra.
• MODEL STATUS – att problemet hade en lösning. 1 Optimal, 2 Locally Optimal (för nlp), 4 Infeasible, 3 Unbounded.

Solve verkstad using lp maximizing z;

* Stoppa programmet om något gick fel
Abort $ (verkstad.modelstat <> 1) "Modellen löste sig inte korrekt";
Display "Optimum:", z.l;

Ett Abort $-test är god sed: hellre ett tydligt fel än vackra men meningslösa siffror.

Skriv ut som en rapport

Display duger för att felsöka, men för riktiga resultat används put som skriver till en textfil:

File res / resultat.txt /;
Put res;
Put "Produktion per produkt", /;
Loop(p, Put p.tl:10, x.l(p):10:2, /);
Put "Total vinst: ", z.l:10:2, /;
PutClose res;

Kapitel 09Vanliga fel – och hur du löser dem

GAMS felmeddelanden är korthuggna men pekar på en rad och en kolumn. Nio av tio fel beror på något av följande.

Fem vanor som förebygger fel

• Skriv beskrivningar på allt: Parameter p(i) "pris i kr per ton";. De syns i utskrifterna och dokumenterar modellen gratis.
• Dela upp filen med rubrikrader:
  * ===== DATA =====
• Deklarera allt överst, tilldela data i mitten, lösa sist.
• Använd Display tidigt och ofta – särskilt för att verifiera att tabeller laddats som du tror.
• En modell i taget: kommentera bort det som inte fungerar, bygg upp stegvis.

Kapitel 10Övningar med facit

Tio uppgifter i stigande svårighet. Skriv koden själv innan du öppnar facit – det är där inlärningen sker. Alla svar kan kontrolleras i GAMS eller för hand.

Set n / 1*10 /;
Parameter k(n) "talen";
k(n) = ord(n);                    * ord ger elementets position: 1,2,...,10

Scalar summa_kvadrater, medel;
summa_kvadrater = sum(n, k(n)*k(n));   * = 385
medel          = sum(n, k(n)) / card(n);  * = 5.5
Display summa_kvadrater, medel;

Set i / 1*3 /;
Parameter u(i) / 1 1, 2 2, 3 2 /;
Parameter v(i) / 1 2, 2 0, 3 1 /;

Scalar dot, nu, nv, theta;
dot   = sum(i, u(i)*v(i));                       * 4
nu    = sqrt(sum(i, u(i)*u(i)));                 * 3
nv    = sqrt(sum(i, v(i)*v(i)));                 * sqrt(5)
theta = arccos(dot/(nu*nv));
Display dot, theta;

Set i / r1*r2 /;
Alias(i, k);

Parameter A(i,k) / r1.r1 1, r1.r2 2, r2.r1 3, r2.r2 4 /;
Parameter B(k,i) / r1.r1 0, r1.r2 1, r2.r1 1, r2.r2 0 /;
Parameter C(i,i);

C(i,i) = sum(k, A(i,k)*B(k,i));
Display C;      * ger [[2,1],[4,3]] – kolumnerna i A har bytt plats

Variable x, y, obj;
Equation e1, e2, dummy_sys;

e1..      2*x +  y =e= 7;
e2..        x -  y =e= 2;
dummy_sys.. obj =e= 0;

Model sys / all /;
Solve sys using lp minimizing obj;
Display x.l, y.l;      * x = 3, y = 1

Positive Variable x, y;
Variable z;
Equation obj, c1, c2;
obj.. z =e= 5*x + 4*y;
c1..  6*x + 4*y =l= 24;
c2..    x + 2*y =l= 6;
Model m / all /;
Solve m using lp maximizing z;
Display x.l, y.l, z.l;

Set p / A, B, C, D, E /;
Parameter vard(p) / A 8, B 11, C 15, D 20, E 4 /;
Parameter vikt(p) / A 2, B 3,  C 4,  D 5,  E 1 /;
Scalar kap / 12 /;

Binary Variable y(p);
Variable z;
Equation mal, kapac;
mal..   z =e= sum(p, vard(p)*y(p));
kapac.. sum(p, vikt(p)*y(p)) =l= kap;

Model knap / all /;
Solve knap using mip maximizing z;
Display y.l, z.l;      * optimum: A+B+C+E = 10 kg, värde 38

Set i / ing1, ing2 /;
Parameter kostnad(i) / ing1 5, ing2 4 /;
Table nar(i,*) "näringsinnehåll"
          protein  fett
ing1         10      2
ing2          4      6;

Parameter krav(*)  / protein 30, fett 20 /;
Positive Variable x(i);
Variable k;
Equation mal;
Equation minst(*);

mal..        k =e= sum(i, kostnad(i)*x(i));
minst("protein").. sum(i, nar(i,"protein")*x(i)) =g= krav("protein");
minst("fett")..    sum(i, nar(i,"fett")*x(i))    =g= krav("fett");

Model foder / all /;
Solve foder using lp minimizing k;
Display x.l, k.l;

Set i / aktie, obl, guld /;
Parameter r(i) / aktie 0.08, obl 0.03, guld 0.05 /;
Parameter w(i);

w(i) = 1/card(i);
Display sum(i, w(i));                * kontroll: 1.0
Display sum(i, w(i)*r(i));           * ca 0.0533

w("aktie") = 0.5; w("obl") = 0.3; w("guld") = 0.2;
Display sum(i, w(i)*r(i));           * 0.059

* Endast dessa rader ändras:
Set p / X, Y, Z /;
Parameter vinst(p) / X 3, Y 2, Z 4 /;
Table atgang(r,p)
           X    Y    Z
maskin     1    2    2
arbete     3    1    2;

Quiz: känner du igen syntaxen?

Checklista – bocka av när du behärskar momentet

• Jag har kört ett GAMS-program och sett utskriften från Display.
• Jag kan deklarera en mängd och använda den som index.
• Jag kan skriva en dubbelsumma och förklara vilka index som försvinner.
• Jag kan skriva ett LP med =e=, =l= och =g= utan att titta i fuskbladet.
• Jag kan tolka .l, .m och .slack i lösningsrapporten.
• Jag kan lösa ett ekvationssystem och ett heltalsproblem i GAMS.

Kapitel 11Fuskblad

Allt på ett ställe. Skriv ut och ha bredvid tangentbordet.

Skelettet

Set      i "index"        / a, b, c /;
Parameter p(i) "data"     / a 1, b 2, c 3 /;
Scalar    c0  "skalär"    / 100 /;

Positive Variable x(i) "beslut";
Variable          z    "målfunktion";

Equation obj, rest(i);

obj..     z =e= sum(i, p(i)*x(i));
rest(i).. sum(i, x(i)) =l= c0;

Model modell / all /;
Solve modell using lp maximizing z;
Display x.l, z.l;

Från formel till kod – i fem steg

1. Vilka index finns? Varje index blir en Set.
2. Vad är givet? Varje given siffra blir en Parameter eller Table.
3. Vad ska bestämmas? Det blir Variable – sätt typ och gränser.
4. Vilka samband gäller? Varje rad i problemformuleringen blir en Equation med rätt relations­tecken.
5. Vad ska maximeras/minimeras? Skriv Solve … maximizing/minimizing och läs .l.