GAMS to LaTeX converter based on PEG.js and Dust.js

1
Fine-tune the PEG.js grammar for GAMS parsing

        

/* Incomplete GAMS grammar (just complete the parts missing for your GAMS script) */

{
  if(typeof document.eolComSymbol !== "undefined") {
     delete document.eolComSymbol;
  }
  if(typeof document.inlineComSymbolStart !== "undefined") {
     delete document.inlineComSymbolStart;
     delete document.inlineComSymbolEnd;
  }
  function makeInteger(o) {
    return parseInt(o.join(""), 10);
  }
  function makeString(o) {
    var theString = o.join("");
    return theString.replace(/^\s+|\s+$/gm,''); // trim output
  }
}

start
  = gamsCode+ 


/////////////////////// General GAMS Code Parsing //////////////////////////


gamsCode 
  = _ part:gamsCodePart _ {return part;}

gamsCodePart 
  = executionStatement
  / definition 
  / assignment 
  / solveStatement
  / multiLineComment
  / dollarCommand 
  / lonelySemicolon 

dollarCommand = inlineComStatement / offInlineComStatement / eolComStatement / offEolComStatement / genericDollarCommand

genericDollarCommand = "$" str:[^\n]+ {return {type:"dollarCommand", value: makeString(str)};}

eolComStatement = "$EOLCOM"i _ eolComSymbol:[^\n\t ]+ _ {document.eolComSymbol = makeString(eolComSymbol); return {type:"endOfLineCommentSetting", value: makeString(eolComSymbol)};}

offEolComStatement = "$offeolcom"i [^\n]* {if(typeof document.eolComSymbol !== "undefined") {
     delete document.eolComSymbol;
  }} 

inlineComStatement = "$inlinecom"i _ inlineComSymbolStart:[^\n\t ]+ _ inlineComSymbolEnd:[^\n\t ]+ {document.inlineComSymbolStart= makeString(inlineComSymbolStart); document.inlineComSymbolEnd = makeString(inlineComSymbolEnd); return {type:"inlineCommentSetting", value: {start: makeString(inlineComSymbolStart),end: makeString(inlineComSymbolEnd)}};}

offInlineComStatement = "$offinlinecom"i [^\n]* {if(typeof document.eolComSymbol !== "undefined") {
     delete document.eolComSymbol;
  }} 


multiLineComment = 
   "$onecho"i str:(!"$offecho"i letter:. {return letter;})+ "$offecho"i {return {type:"onecho" /*, makeString(str) */}}
   / "$ontext"i str:(!"$offtext"i letter:. {return letter;})+ "$offtext"i {return {type:"ontext" /*, makeString(str) */}}

executionStatement = optionStatement / solveStatement / abortStatement / controlStructureStatement / defaultStatement 

abortStatement =  _ "abort"i conds:(_ conds:dollarCondition {return conds;} / whiteSpacePart {return null;}) _ args:defaultArguments? _ ";" {return {type:"abort", conditions:conds, arguments:args}}

controlStructureStatement = _ type:("loop"i / "while"i / "if"i) _ "(" _ sets:set_or_setsInBrackets conds:dollarCondition? _ "," parts:gamsCode* ")" {return {type:type, sets:sets, conditions:conds, contents:parts}} / forStatement / repeatStatement 

repeatStatement = _ type:"repeat"i _ "(" parts:gamsCode* "," _ sets:set_or_setsInBrackets conds:dollarCondition? ")" {return {type:type, sets:sets, conditions:conds, contents:parts}}

forStatement = _ type:"for"i _ "(" _ sets:set_or_setsInBrackets conds:dollarCondition? _ "to"i _ endValue:set_or_setsInBrackets _ "," parts:gamsCode* ")" {return {type:type, sets:sets, endValue:endValue, conditions:conds, contents:parts}}

// The default parts just contain things not otherwise handled in detail
defaultStatement = type:("display"i / "execute"i) whiteSpacePart args:defaultArguments ";" {return {type:type,arguments:args}}

defaultArguments = _ arg1:defaultArgument _ moreArgs:("," _ arg:defaultArgument _ {return arg;})* _ {return moreArgs?[arg1].concat(moreArgs):[arg1];}

defaultArgument = letters:[^,;]+  _ {return makeString(letters);}


solveStatement = _ 
   "solve"i _ 
    modelName:literalString _ 
    secondPart:solveStatement_secondPart 
    ";" 
          {return {type: "solveStatement", modelName: modelName, 
                   modelType:secondPart.modelType, 
                   optimizationType:secondPart.objective?secondPart.objective.optimizationType:null,
                   objective:secondPart.objective?secondPart.objective.objective:null};}

solveStatement_secondPart = modelType:modelTypeStatement _ objective:objectiveStatement? 
                            {return {objective:objective, modelType:modelType};}
    / objective:objectiveStatement _ modelType:modelTypeStatement
                            {return {objective:objective, modelType:modelType};}

modelTypeStatement = ("using"i / "use"i) _ modelType:literalString _ {return modelType;}

objectiveStatement = optimizationType:("minimizing"i {return "min";} / "maximizing"i {return "max";} / "min"i / "max"i) _ objective:literalString _ {return {optimizationType:optimizationType, objective:objective};}

lonelySemicolon = _ ";" {return {"type":"lonelySemicolon"};}

// Assignments
// E.g. MyParam(i) = 2+(3*5) + sum(j,costs(i,j)) * MY_VAR.l(i) + (1 > 2) + (2 = 3);

assignment
  = _ param:parameter _ "=" _ valueSide:equationSide ";" {return {"type":"assignment", "param":param, "value": valueSide}}

// Dollar conditions
// E.g. $(condition1$(condition2))

dollarCondition = 
  "$" _ "(" eq:equationSide eqs:dollarCondition? _ ")" _ 
          {return eqs?[eq].concat(eqs[1]):[eq];} 
  / "$" eq:functionalPart 
          { return [eq];} 

optionStatement = "option"i optionText:[^\;]+ ";" {return {"type":options, "options":makeString(optionText)};}


/////////////////////////// Definitions ////////////////////////////

definition 
  = multipleItemsDefinition / aliasDefinition  / parameterDefinition  / tableDefinition 
  / equationDefinition 
  / assignment

descriptionString = letters:noSetCharacter+ {return makeString(letters);}

noSetCharacter = !"set:"i char:[^\/\n\;\|] {return char;}

descriptionStringWithPipe = letters:[^\/\n\;]+ {return makeString(letters);}

latexDefinition = "|LaTeX:"i _ latexParams:(latexSetDefinition  / desc:descriptionString {return {latex:desc,latexSet:"",latexIndex:""}}) {return latexParams;}

latexSetDefinition = _ "index:"i _ index:descriptionString _ "set:"i _ set:descriptionString  {return {latex:index+" \\in "+set,latexSet:set,latexIndex:index};}

multipleItemsDefinition = type:multipleItemTypes whiteSpacePart items:itemDefinition+ _ ";" {return {"type":"definition", definitionType:type.toLowerCase(), items: items};}

itemDefinition = 
    _ name:literalString noNewLineWhiteSpace? sets:setsOrNothing noNewLineWhiteSpace? desc:descriptionString?  latexParams:latexDefinition? desc2:descriptionStringWithPipe? _ value:itemValueDefinition? 
    {return {name:name, sets:sets, desc:desc2?desc+desc2:desc, latex:latexParams?latexParams.latex:"", latexSet:latexParams?latexParams.latexSet:"", latexIndex:latexParams?latexParams.latexIndex:"", value:value}}

itemValueDefinition = "/" _  value:[^\/]+ _ "/" {return makeString(value);}

multipleItemTypes = type:parameterType "s"i? {return type;}

parameterDefinition 
  = type:parameterType whiteSpacePart item:itemDefinition _ ";" {return {type:"definition",definitionType:type.toLowerCase(),items:[item]};}

parameterType = "set"i / "parameter"i / "variable"i / "binary variable"i / "positive variable"i / "scalar"i / "equation"i / "model"i

tableDefinition = "table"i _ name:literalString _ sets:setsOrNothing _ desc:descriptionString latex:latexDefinition? valueLetters:[^\;]+ ";" {return {type:"definition", definitionType:"table", name:name, sets:sets, desc:desc, latex:latex, value:makeString(valueLetters)};}


aliasDefinition = "alias"i _ items:aliasItem moreItems:("," _ items:aliasItem {return items;})* _ ";" {return {type:"definition", definitionType:"alias", items:[items].concat(moreItems)};}

aliasItem = _ "(" sets:sets ")" {return sets;}


equationDefinition 
  = eqName:literalString sets:setsOrNothing _ dollarCond:dollarCondition? _ ".." leftHand:equationSide operator:equationOperator rightHand:equationSide ";" _ {return {type:"equation", name:eqName, setsAndConditions: {sets:sets, conditions:dollarCond}, operator:operator, leftHand:leftHand,rightHand:rightHand}}

//////////////////////////// Equation Parsing //////////////////////////////

equationSide
  = _ exp:logicRelExpression _ {return exp;}

logicRelExpression =  
    _ operator:logicRelOperator _ part2:logicRelExpression  
        {return {type:"operation", operator:operator,secondPart:part2};}
  / 
    _ part1:numericalRelExpression _ operator:logicRelOperator _ part2:logicRelExpression  
        {return {type:"operation", operator:operator,firstPart:part1,secondPart:part2};}
  / numericalRelExpression

logicRelOperator = "not"i / "and"i / "or"i / "xor"i

numericalRelExpression = ( _
      part1:additiveExpression _ operator:numericalRelOperator _ part2:numericalRelExpression  
        {return {type:"operation", operator:operator,firstPart:part1,secondPart:part2};}
  )
  / additiveExpression

numericalRelOperator = "<" / "<=" / "<>" / ">=" / ">" / "gt"i {return ">";} / "lt"i {return "<";} / "eq"i {return "=";} / !equationOperator "=" {return "=";}

additiveExpression = ( _
          part1:multiplicativeExpression?  _ operator:[\+\-] _ part2:additiveExpression  
        {return {type:"operation", operator:operator,firstPart:part1,secondPart:part2};}
    )
    / multiplicativeExpression

multiplicativeExpression = ( _
          part1:exponentialExpression _ operator:[\*\/] _ part2:multiplicativeExpression 
        {return {type:"operation", operator:operator,firstPart:part1,secondPart:part2};}
    ) 
    / exponentialExpression 

exponentialExpression = ( _
          part1:functionalPart _ operator:"**" _ part2:exponentialExpression 
        {return {type:"operation", operator:operator,firstPart:part1,secondPart:part2};}
    ) 
    / functionalPart

functionalPart
  = primary / function / parameter  /* / someString */

primary = val:float {return {type: "float", value:val};} / val:integer  {return {type: "integer", value:val};} /  ( _  "(" _ exp:logicRelExpression _ ")" _ {return {type:"parentheses", contents:exp};} )

float = (
    integerPart:[0-9]+ "." floatPart:[0-9]+ 
         {return parseFloat(integerPart.join("")+"."+floatPart.join(""))}
   )

someString
  = theValue:[^\=]+ 
  {return makeString(theValue);}

parameter
  = name:literalString suffix:suffix? _ sets:setsOrNothing dollarCond:dollarCondition?
  {return {"type":'param', "name":name, conditions:dollarCond, sets:sets, "suffix":suffix};}


setsOrNothing = "(" sets:sets ")" {return sets;} /

suffix = "." suffixLetters

suffixLetters = "lo"i / "l"i / "fx"i / "up"i / "m"i / "nd"i / "nz"i / "nr"i / "nw"i / literalString 
// literalString is added for the modelname.option = XYZ syntax (e.g. mymodel.iterlim=10).

sets
  = set:set sets:("," sets:sets {return sets;})? {return sets?[set].concat(sets):[set];}

set
  = _ "'" setName:[^\']+ "'" _ {return {type:"specificElement",name:makeString(setName)};} 
  / _ '"' setName:[^\"]+ '"' _ {return {type:"specificElement",name:makeString(setName)};} 
  / _ exp:logicRelExpression _ {return exp;}

function
  = ( funcName:functionName _ "("  sets:set_or_setsInBrackets dollarCond:dollarCondition? "," _ functionContents:logicRelExpression _ ")" _ dollarCondAfter:dollarCondition? _ {return {type: 'function', funcName:funcName.toLowerCase(), conditions:(dollarCondAfter?(dollarCond?dollarCond.concat(dollarCondAfter):dollarCondAfter):dollarCond), sets:sets, functionContents:functionContents};} )

functionName
  = "sum"i / "smax"i {return "max";} / "prod"i / "smin"i {return "min";}
 
set_or_setsInBrackets
  = _ set:set _ {return [set];} / _ "(" _ sets:sets _ ")" _  {return sets;}

sqrt
  = ( "sqrt" _ "(" additiveExpression  ")")

equationOperator 
  = "=e="i {return '=';}
  / "=g="i {return '>';}
  / "=l="i {return '<';}

//////////////////////////// Basics //////////////////////////////

integer "integer"
  = digits:[0-9]+ { return parseInt(digits.join(""), 10); }

_ "whitespace" = whiteSpacePart* {return "whitespaceOrComment";}

whiteSpacePart = comment / [ \n\t\r] / endOfLineComment

endOfLineComment = & {return typeof document.eolComSymbol !== "undefined"}  chars:[^\n]+ & {return makeString(chars).substr(0,document.eolComSymbol.length) === document.eolComSymbol}

noNewLineWhiteSpace = [ \t\r]+ {return "whitespaceOrComment";}

literalString 
  = (firstLetter:[A-Za-z_] nextLetters:[A-Za-z0-9_]* {return firstLetter + makeString(nextLetters);})

comment 
  = ([\n] "*") [^\n]* {return "comment";}

Parser built successfully.0.52 kB, 32 ms, 16 kB/s

2
Enter your GAMS code



SETS
   I   canning plants |latex: index:i set:I / SEATTLE, SAN-DIEGO /
   J   markets     |latex: index:j set:J      / NEW-YORK, CHICAGO, TOPEKA / ;
PARAMETERS
   A(I)  capacity of plant i in cases  |latex:\alpha
	 /    SEATTLE     350
		  SAN-DIEGO   600  /
   B(J)  demand at market j in cases  |latex:\beta
	 /    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/ ;
PARAMETER C(I,J)  transport cost in thousands of dollars per case |latex:c ;
		C(I,J) = F * D(I,J) / 1000 ;
VARIABLES
   X(I,J)  shipment quantities in cases |latex:x
   Z       total transportation costs in thousands of dollars |latex:z ;
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=  B(J) ;
MODEL TRANSPORT /ALL/ ;
SOLVE TRANSPORT USING LP MINIMIZING Z ;

Input parsed successfully.0.0068 kB, 4 ms, 1.7 kB/s

3
Watch the abstract syntax tree (AST)

Output

4
Write Dust.js helper functions (if needed)

{
			// See: http://labs.zavoo.com/?p=356 for example code on dust helper functions
    getGamsSymbol: function(chunk, context, bodies, params) {
        if(!params.data)     {
            console.log("Missing parameter 'data' for helper function.");
            return chunk;
        } 
         
        var string= params.property;  
        
            if(params.setMode)
                console.log(params.setMode);        
        
            if(params.field === 'latex') {
                var result = string;
//                var result = "\\text{"+string+"}";
            } else {
                var result = string;
            }      
             
            if(params.data) {               
                $.each(params.data, function( key, value ) {
                    if (value.type === "definition" && value.items) {
                        $.each(value.items, function(subKey, subValue) {
                            if(subValue.name === string && subValue[params.field]) {
                                result = subValue[params.field];
                                            
                                if(params.field === 'latex' && params.setMode) {
                                    if(params.setMode === "index" && typeof(subValue.latexIndex) !== 'undefined' && subValue.latexIndex) {
                                        result = subValue.latexIndex;
                                    }    
                                }
                            }
                        });        
                    }
                });
            }   
            return chunk.write(result);

}
}

5
Write your Dust.js template

{#structure} 
  {@eq key=type value="solveStatement"}
    {+solveStatement  /}
  {/eq} 
{/structure}

{#structure}
  {@eq key=type value="equation"}
    {+equation  /}
  {/eq} 
{/structure}
 
{+variableListing listingType="set" /}
{+variableListing listingType="parameter" /}
{+variableListing listingType="variable" /}
{+variableListing listingType="positive variable" /}
{+variableListing listingType="binary variable" /}

{<solveStatement}
  {?objective}
  {~n}Objective Function:{~n}{~n}
  \begin{~lb}equation{~rb}{~n}{~s}{~s}{~s}{~s}
    \{optimizationType}{~lb}
    {~s}\left({~s}
		{@getGamsSymbol data=structure field="latex" property=objective /}
    {~s}\right){~s}{~rb}
    \mspace{40mu} s.t.:
    {~n}
  \end{~lb}equation{~rb} {~n}{~n}{~n}
  {/objective}
{/solveStatement}

{<equation} 
  {~n}
  {@getGamsSymbol data=structure field="desc" property=name/}
  {~n}{~n}
  \begin{~lb}equation{~rb}{~n}{~s}{~s}{~s}{~s}
      {+"{leftHand.type}" exp=leftHand setMode="index" /} 
      {operator|s} 
      {+"{rightHand.type}" exp=rightHand setMode="index" /} 
      \mspace{40mu}
      {?setsAndConditions.sets}{~n}{~s}{~s}{~s}{~s}\forall\thinspace{~lb}{+sets sets=setsAndConditions.sets conditions=setsAndConditions.conditions setMode="set" /}{~rb}{/setsAndConditions.sets}  
      {~n}{~s}{~s}{~s}{~s}
      \label{~lb}eq:{name}{~rb}{~n}
  \end{~lb}equation{~rb} {~n}{~n}{~n}
{/equation}

{<integer}
  {exp.value}
{/integer}

{<float}
  {exp.value}
{/float}

{<operation}
    {+"{exp.firstPart.type}" exp=exp.firstPart setMode=setMode /} 
    {+operator operator=exp.operator /} 
    {+"{exp.secondPart.type}" exp=exp.secondPart setMode=setMode /}
{/operation}

{<operator}
    {@eq value="*" key="{operator}"}
        \cdot
    {:else}
        {@eq value="**" key="{operator}"} 
            ^
        {:else}
            {operator|s}{~s}
        {/eq}
    {/eq}
{/operator} 

{<parentheses}
    \left({+"{exp.contents.type}" exp=exp.contents setMode=setMode /}\right)
{/parentheses}

{<param}
    {@getGamsSymbol data=structure field="latex" setMode=setMode property=exp.name /}
    {+setsAsSubscript sets=exp.sets conditions=exp.conditions /}
{/param}
 
{<function}
    \{exp.funcName}
    \limits_{~lb}{+sets sets=exp.sets conditions=exp.conditions setMode="set" /}{~rb} 
    \left( 
        {+"{exp.functionContents.type}" exp=exp.functionContents setMode="index" /}
    \right) 
{/function}

{<singleSet}
    {@getGamsSymbol data=structure field="latex" setMode=setMode property=setName /}
{/singleSet}

{<specificElement}
    \mathrm{~lb}{name}{~rb}
{/specificElement}

{<setsAsSubscript}
    {!The trick here is to render the subscript mark 
      only if either sets or conditions are defined!}
    {?sets}
        _{~lb}
    {:else}
         {?conditions[0]}
             _{~lb}
         {/conditions[0]}
    {/sets}
    {+sets /}
    {?sets}
        {~rb} 
    {:else}
         {?conditions[0]}
             {~rb}
         {/conditions[0]}
    {/sets}
{/setsAsSubscript}

{<sets}
  {#sets}
    {+"{type}" exp=. setMode=setMode /}
    {@sep},{/sep}
  {/sets}
  {?conditions[0]}
       \thinspace \operatorname{~lb}if{~rb} \thinspace 
     {#conditions}
       {+"{type}" exp=. conditions="" /}{! conditions="" is to stop recursion !}
       {@sep},{/sep} 
     {/conditions}
  {/conditions[0]}
{/sets}


{<variableListing}
    {+ htmlVariableListing /}
    {+ latexVariableListing /}
{/variableListing}

{<latexVariableListing}
    {~n}%<!--
    {~n}\begin{~lb}table{~rb}
    {~n}{+tab /}\begin{~lb}tabular{~rb}{~lb}l | l{~rb}
        {~n}{+tab /}{+tab /}
        \hline
        {~n}{+tab /}{+tab /}
	{listingType}s & description \\ 
        {~n}{+tab /}{+tab /}
	\hline
        {~n}{+tab /}{+tab /}
	\hline
        {#structure} 
          {@eq key=type value="definition"}
            {@eq key=definitionType value=listingType}
              {#items}
                {?latex}
                 {~n}{+tab /}{+tab /}
                 ${@getGamsSymbol data=structure field="latex" setMode=setMode property=name /}$
                 & {desc} \\
                {/latex}
              {/items}
             {/eq} 
          {/eq} 
        {/structure}
    {~n}{+tab /}{+tab /}\hline
    {~n}{+tab /}\end{~lb}tabular{~rb}
    {~n}{+tab /}\caption{~lb}{listingType}s{~rb}
    {~n}\end{~lb}table{~rb}
    {~n}%-->
{/latexVariableListing}

{<tab}
    {~s}{~s}{~s}{~s}
{/tab}

{<htmlVariableListing}
    {~n}{~n}%<table border="1" width="800" style="margin-bottom: 20px;">
        <tr><td colspan="2"><strong>{listingType}s</strong></td></tr>
        {#structure} 
          {@eq key=type value="definition"}
            {@eq key=definitionType value=listingType}
              {#items}
                {?latex}
                 <tr>
                    <td style="width:200px;">${@getGamsSymbol data=structure field="latex" setMode=setMode property=name /}$</td>
                    <td style="width:600px;">{desc}</td>
                 </tr>
                {/latex}
              {/items}
             {/eq} 
          {/eq}  
        {/structure}
    </table>{~n}
{/htmlVariableListing}

6
Watch the generated LaTeX

TeX code here

7
View the result

\begin{equation} E = mc^2 \end{equation}

1 Fine-tune the PEG.js grammar for GAMS parsing

2 Enter your GAMS code

3 Watch the abstract syntax tree (AST)

Output

4 Write Dust.js helper functions (if needed)

5 Write your Dust.js template

6 Watch the generated LaTeX