MRL – MeOS Result Language

Uppdaterad: 2015-02-20

MRL (MeOS Result Language) är MeOS språk för att beskriva resultatuträkning. För att kunna skapa egna resultatuträkningsregler är en viss programmeringskunskap nödvändig. Har du skrivit programsnuttar i Java, PHP, C++, C# eller liknande språk har du troligtvis de förkunskaper som krävs.

Grunder

En MRL-rutin består av en följd av satser som separeras genom semikolon (;). En lämplig formattering av koden är att avsluta varja rad med semikolon. Semikolonet kan uteslutas för den sista satsen i rutinen.

Kommentarer i koden kan ges efter genom att skriva // på en rad, varefter resten av denna rad ignoreras. Exempel:

if (Status != StatusOK)
return 10000; // Return a number higher than any valid time.
else
return ComputedTime;

Varje MLR-rutin beräknar och returnerar ett heltal (som tolkas som en tid i sekunder, en poäng eller en löparstatus) utifrån indata (tillgängliga symboler). Det sist beräknade uttrycket i rutinen blir returvärdet. För att returnera ett specifikt värde används konstruktionen

return ;

som i exemplet ovan.

Symboler

I varje MRL-rutin finns ett antal symboler tillgängliga, t.ex Status, Time och Course, som varje gång rutinen körs innehåller aktuell data för den deltagare eller det lag som behandlas.

Symboler kan vara av skalär typ (ex. Time, som håller deltagarens eller lagets tid), av vektortyp (ex. Course, som innehåller en deltagares bana), eller av matristyp (ex RunnerCourse, som innehåller alla banor för ett lags deltagare.).

Symboler av vektortyp och matristyp indexeras från 0 med hakparenteser: Course[2] innebär den tredje kontrollen, RunnerCourse[2][0] innebär den första kontrollen för den tredje deltagaren i laget.

För att ta reda på en vektors eller matris storlek används syntaxen Course.size() respektive RunnerCourse[2].size(); (Antal kontroller för den tredje deltagaren i laget). Exempel: En beräkning av status för deltagare där sträcktid över 3 minuter medför diskning.

if (Status == StatusOK) {
  for (i = 0; i < SplitTimes.size(); i++) {
    if (SplitTimes[i] > 60*3)
      return StatusDQ; // Disqualified if split time over 3 minutes
  }
}
return Status;

Variabler

Variabler fungerar på liknande sätt som symboler, men du definierar dem själv genom att tilldela ett värde. Alla variabler är heltal eller vektorer av heltal. I exemplet ovan är i en variabel.

En variabel som är en vektor kan konstrueras genom att tilldela den värden för specifika index. Vektorn växer automatiskt för att räcka till och talet 0 fylls i där inget tal angivits. Om du skriver var[3] = 4 (och var inte var hade något värde sedan tidigare) blir var en vektor med innehåll [0,0,0,4].

En vektorvariabel kan också bildas genom tilldelning av alla värden på en gång. Det händer om du skriver var = där namn är namnet på en symbol som är en vektor, t.ex RunnerCourse[0] (banan för den första lagmedlemmen, hela RunnerCourse är av matristyp) eller en annan vektorvariabel.

Du kan sortera en vektorvariabel genom att skriva var.sort(). Exempel på funktion som returnerar tiden för den snabbaste lagmedlemmen:

times = RunnerTimes;
times.sort();
return times[0];

Operatorer

MRL innehåller de vanligaste aritmetiska och logiska operatorerna. Logiska operatorer evalueras till 1 om värdet är sant och 0 om värdet är falskt. Vanliga prioritetsregler gäller, använd parenteser vid behov.

Binära aritmetiska operatorer

+: Addition (a+b)
-: Subtraktion (a-b)
*: Multiplikation (a*b)
/: Division (a/b)
%: Resten vid heltalsdivision (a%b)
max: Största värdet (max(a,b))
min: Minsta värdet (min(a,b))

Binära logiska operatorer

En uttryck är sant om det inte är 0.

==: Lika (a == b)
!=: Olika (a != b)
<: Mindre än (a < b)
>: Större än (a > b)
<=: Mindre än eller lika (a <= b)
>=: Större än eller lika (a >= b)
&&: Och, båda sanna (a && b)
||: Eller, minst ett sant (a || b)

Unära operatorer

!: Icke (!a), sant om och endast om a är falskt
-: Minus (-a)
++: Öka variabel med 1 (++a eller a++)
--: Minska variabel med 1 (--a eller a--)

Operatorerna ++ och -- kommer i två varianter, en före och en efter variabeln. Skillnaden ligger i hur uttrycket själv evalueras. Står operatorn först blir resultatet uttrycket efter förändring, annars blir det uttrycket före förändring.

a = 0;
b = ++a;
c = a++;

Resultatet är att b är 1, c är också 1, och a är 2. Undvik att skriva b = ++a + a++;

Flödeskontroll

if/else satser För att räkna olika beroende på om ett logiskt uttryck är sant eller falskt, används en if/else sats. Konstruktionen är:

if () {
//kod som körs om är sant
} else {
//kod som körs om är falskt
}

Delen med else kan utelämnas, om ingen sådan kod ska köras. Man kan också välja mellan flera utfall, genom konstruktionen:

if () {
  //kod som körs om  är sant
} else if( {
  //kod som körs om   är falskt och  är sant
} ... {
} else {
  //kod som körs om inget uttryck var sant.
}

for-loopar En for-loop används för att repetera en beräkning ett antal gånger. Konstruktionen är

for (; ; ) {
// Kod som körs.
}

Först utförs uttrycket . Sedan körs loopen ett varv till så länge är sant är början på loopen. Efter varje varv, körs uttrycker , precis in villkoret utvärderas för nästa varv.

Följande exempel returnerar status godkänd om alla deltagare i ett lag är godkända.

for (i = 0; i < RunnerStatus.size(); i++) {
if (RunnerStatus[i] != StatusOK)
return RunnerStatus[i];
}
return StatusOK;

while-loopar While-loopar är ett alternativ till for-loopar, som saknar start och uppdatering, loopen körs så länge villkoret är sant. Konstruktionen är enklare:

while () {
// Kod som körs.
}

break Break används inne i en loop för att avbryta körningen, oavsett villkoret i loopen. Exempel (beräknar en poäng beroende på antalet sträckor i rad man klarat på under 1 minut):

i=0;
while (++i < CardTimes.size()) {
if (CardTimes[i] - CardTimes[i-1] > 60)
break;
}
return i-i;

För att kommentera innehållet måste du vara inloggad. Logga in