On this page you will find detailes regarding changes in different Gekko versions. On the download pages, you will find only brief descriptions of changes, whereas this page goes in more detail.

• Bugfix: substitution of {s} and {%s} did not work inside strings. This meant that for instance "PRT x{s};" or "PRT x{%s};" showed this verbatim in the print labels, without in-substituting the name part.
• Bugfix: There was a problem with calling multiple PLOT's in a command file, and afterwards hitting for example the '%' radion button.
  
• The help file topics have been updated. So clicking 'Index' on the help file is now much more meaningful!
  

• Fixing some minor glitches, mostly related to PRT/MULPRT and printcodes. Also some help file updates.

• Gekko 2.0 is now official, no more beta's and gammas (for now)! But there will probably be some patches in the 2.0 line...
  
• New option 'OPTION interface databank swap = yes|no'. If 'yes', databank swapping via the F2 windows is allowed, else not. The UNSWAP command is kept, since it has its purposes and does not harm in itself (it is similar to CLOSE *).
  
• Improved layout regarding html tables and print-code clicking. Now, a link with the text 'Transform options' is provided, and the print-codes fold out when clicking. The printcodes are set up in a way that mimics the DECOMP window layout a bit. This link can be deactivated with OPTION interface table printcodes = no.
  
• Bugfix: PRT<filter=avg> and these timefilters in general seem to work again (hopefully, not tested completely).
  
• Bugfix: A bug made the input window stay gray after an error.
• Bugfix: Table navigation with the new print-code buttons (in html mode) did not work properly when navigating back.
• Bugfix: In command files, we might imagine having these commands: 'DECOMP fy; DELETE fy.'. This should be possible, since 'DELETE fy' should wait for the decomp windows to finish loading data. But this is not what happened, because Gekko asked the window to open in parallel, while continuing the commands (the DELETE statement). This means that when the decomp window opened, the 'fY' variable had gone. This is fixed, so that the Gekko program waits for the decomp window to initialize.

• New COUNT command (simple version of INDEX command).
• INDEX command will now print the found items (series) on screen, unless you use INDEX<mute>.
  
• Flowcharts have been around for a while as an experiment, but are now made more visible to the user. Try DECOMP some variable, and choose either a 'Time-change' or 'Multiplier' option. After this, you may right-click a particular time period in the row of time periods. These flowcharts are still experimental, and should be further prettified. What they do is essentially to track the contributions recursively (the contributions shown when you choose 'Show as shares'). Green arrows are positive contributions, and red arrows are negative contributions, and the arrow widths reflect their sizes.
• Quitting Gekko through the user interface will now issue a warning box no matter how you do it (including Alt-F4). Still, the EXIT command will quit without warning (so that Gekko may run jobs without user intervention).
• Bugfix regarding printcodes in tables fixed (sometimes the printcodes were unresponsive)
• Bugfix regarding WRITE <xlsx> #list file=.... , and other types than xlsx, too. This did not work for quarterly and monthly frequencies.
  

• The mode colors have been removed from the input field and moved to the status bar instead.
• When you hit 'Close' (X) on the main Gekko windows, you will have to confirm quitting. This is to avoid losing Gekko code/commands inadvertently.
  
• The function fromSeries() can now return the start and ending dates of the actual (non-missing) data in the timeseries, using parameters 'dataStart' or 'dataEnd'. Use for instance DATE d = fromSeries('fX', 'dataStart').
  
• Bugfix: there was a bug related to X12A and monthly data.
  
• Bugfix: in the DECOMP window, you could not click on contributions (precedents) if you were not showing 'raw' data.
• Bugfix in help files: You must use SERIES<keep=p>, and not just SERIES<keep>.
  

• The names of the file extensions have changed. So 'gek' is now 'gcm' (command files), 'tsdx' is now 'gbk' (databank files), and 'tab' is now 'gtb' (table defintion files). You should rename accordingly. At some point in the future, 'frm' will become 'gfm' or something similar.
• The MODE command now sets colors: green for sim, blue for data, and yellow for mixed.
  
• New 'OPTION system code split'. This splits up generated C#-code internally into smaller methods, which makes long non-looping command files compile and run faster. Default value is 10, but the value of 0 switches this code-splitting off completely if it poses problems.
  
• Bugfix: There were some problems with SERIES <%t1 %t2> #m = ... . This has been resolved.

• New ANALYZE command (cross-correlations etc.)
  
• New ACCEPT command (interactive user input)
• Preliminary version of printcode-clicking on tables (for instance 'p' for percentage growth). Will be refined.
  
• CLEAR of Work or Ref now reflects better on the status line at the bottom of the main window.
  
• DELETE logic is changed a little bit, so that "DELETE var1;" only gives a warning and not en error, if var1 does not exist (it does give an error, however, if you are trying "DELETE bank1:var1;", and bank1 is not open). This logic mirrors CREATE, where there is only a warning issued, if the variable already exists.
• There were a couple of bugs related to NAMEs (or loop-variables). Firstly, you could not do VAL v%n = 100, and secondly, you could not do for instance CREATE %n. In both cases, %n is a NAME. This is fixed.

• Some bugfixes related to tables called from menus. Other minor bugs have been fixed, too.
  
• Quite a lot of improvements regarding the AREMOS translator. See the help file under TRANSLATE (and follow the link to 'details') to see the newest capabilities.

• This version mostly contains TRANSLATE improvements. Both TRANSLATE<gekko18> and TRANSLATE<aremos> now report line and position if the translation breaks down. Both translators now have a detailed list of what is being translated in the help system, see the TRANSLATE help file (and the link to the detailed lists).
  
• TRANSLATE<gekko18> now translates ADD to RUN. This translator is more or less done.
  
• TRANSLATE<aremos> har quite a few improvements, and translates much of the tedious stuff by now. It is still in continuous development.
  
• New iif() function, to avoid explicit time looping when you need to condition on the values of timeseries observations. For instance, SERIES y = iif(x1, '<=', x2, 50, 100); This will compare timeseries x1 and x2 using the logical operator '<=' for each observation, and if the condition is true, y will be set to 50, or else 100. The function accepts any kind of expressions as inputs, but the second argument must be a string. AREMOS has SERIES y = IF ... THEN ... ELSE ..., and the iif() function fills in that gap. The name 'iif' comes from VBA and others; using if() would simply be too confusing, since we already allow IF(...) as an if-statement.
  

• Quite a few commands did not work properly with other frequencies than annual, due to limited testing on quarters and months. This has been fixed pretty thoroughly.
  
• For frequencies quarterly and monthly, printing with PRT/MULPRT is now much nicer, separating the year and the quarter/month, cf. OPTION print freq = [pretty|simple], where 'pretty' is default.
  
• With 'pretty' set (cf. above), you can now use PRT<collapse>, PRT<collapse=avg> or PRT<collapse=total>. This will show averages or totalled values for each year of data. Such collapsing can also be set globally with OPTION print collapse = [avg|total|none]. See also the similar COLLAPSE command.

• Importing data from Excel files cell-by-cell is now possible with SHEET<import>. SHEET<import> puts any sequence of Excel cells into timeseries, from any location in the spreadsheet. (Hitherho, the SHEET command could only export to Excel, and this means that the AREMOS procedures EXCELIMPORT and EXCELIMPORT are now both fully supported).
  
• The databank logic has been changed somewhat. The distinction primary/secondary is dropped, and instead the secondary databank (which in Gekko 2.0 was called the baseline databank) is called the reference databank (the primary databank keeps its name). Syntax change is therefore READ<ref> instead of READ<sec>. Similarly, OPEN<ref> instead of OPEN<ref>, even though opening a bank like this is not really recommended. In the F2 window, the reference databank is in the second row as before, but it is now labelled 'REF' instead of '2'. This is because the reference databank is not searchable with OPTION databank search = yes. The reference databank is simply skipped when searching databanks for timeseries, which makes things a bit more simple especially in data-mode. So when databanks are searched, Gekko starts with row one on the F2 list (labelled '1'), then skips row two on the F2 list (labelled 'REF'), then searches row three on the F2 list (labelled '2'), then searches row four on the F2 list (labelled '3') and so forth.
• As a concequence of the above, you may now use ref:x as an alternative to @x, and in general the 'sec' keyword is replaced with 'sec', for instance CLEAR <ref>. Some of the short printcods have been in concequence, so that it is no 'r', 'rd', 'rp', and 'rdp' instead of 's', 'sd', 'sp', and 'sdp'.
• The reference databank is only shown in the F2 window when it contains variables. Hence, in data-mode, the reference databank usually does not show up in F2 at all.
  
• EXPORT<gnuplot> has been added. It writes a prn-like format suitable for gnuplot.
  
• "MODE ?" and "TIME ?" possible.
• TRIMVARS is now DELETE<nonmodel>.
  
• PLOT can (again) produce files with FILE=filename (.emf, .svg or .png).
  
• A bug regarding EXPORT<xlsx> is fixed.
  

• The new MODE command switches between sim mode (model simulation), data mode (data revision programs etc.), and universal mode (a synthesis of sim and data mode). This command will be continuously refined.
  
• UPD has been merged into SERIES, so please use SERIES (or SER) instead of UPD.
• To supplement the former UPD operators '^', '%', '+', '*' and '#', Gekko now has the possibility to also use the so-called short printcodes 'd', 'p', 'm', 'q', and 'mp', respectively. So you may use "SERIES y ^ 10;" or "SERIES <d> y = 10;" interchangeably. Please note that '*' and 'q' must use different input, for instance "SERIES y * 0.85;" corresponds to "SERIES <q> y = -15;". With the short printcodes, the SERIES and PRT commands are symmetric: for instance if "SERIES <d> y = 5;", the command "PRT<d> y;" will print out '5'. This symmetry holds for all the other short printcodes, that is, 'd', 'p', 'm', 'q', and 'mp'. The <keep> keyword corresponds to the '$' operator, so "SERIES y %$ 7, 5, 4;" corresponds to "SERIES <p keep> y = 7, 5, 4;" (keeping the after-sample growth rate equal to what is was before).
  
• UPDPRT has been removed, please use EXPORT instead. For instance, "EXPORT <series = '%'> data;" or "EXPORT <series = p> data;" both create a data.gek file with SERIES statements. Use "EXPORT <series>", to get SERIES statements in levels.
  
• LABEL has been renamed to TARGET. LABEL had too many associations to timeseries labels.
• EDIT command to edit or view files from Gekko (opens up Notepad)
• Damping in SIM is now defined as 1 minus the old damping, so if you use for instance OPTION solve gauss damp = 0.25, you should change this to OPTION solve gauss damp = 0.75.
• Timeseries source (expressions) and time stamps are now recorded, when performing for instance SERIES or SIM commands. For instance, after the command "SERIES y = x * x;", the DISP command will afterwards show this expression as source, and the current date (time stamp) will be kept, too, so that it is easy to see when a timeseries was last changed. Timeseries labels, source and time stamps are stored in .tsdx files, and can be read and written from those (and from .tsd files, see below).
• When issuing a WRITE command, info regarding the model, last simulation period etc. is kept inside the .tsdx file. This is provided that a model has been loaded, and Gekko checks that all the endogenous variables of the model exists in the primary databank before such model info is written to the .tsdx file. After this, when READing the databank again, a link to this model info is provided, acccessing this information. This can be practical when in doubt about when the variables in a given databank were simulated, the simulation period, the model name and signature, etc.
  
• Labels, source (expressions) and time stamps (last change) from .tsd files are now handled correctly, both when reading and writing .tsd files.
• New DOC command to 'manually' change meta information on timeseries. For instance "DOC fY label='Gdp' source='Statistics Denmark'  stamp = '11-01-2015';". You may use empty string '' (two single quotes) to clear, for instance "DOC fy label='';".
  
• When EXPORTing a .tsd file, the default is now to write the variable names with all caps. This is because AREMOS fails if this is not done. To avoid the caps, you may use option <tsd caps=no>.
  
• Bugfix: SHEET or CLIP with more than about 6 times failed. This is fixed.
  

• This version is a first gamma version, that is, a so-called release candidate. So the version should be reasonably stable and bug-free, and the syntax is practically frozen (except for really minor stuff). It is expected that this version will soon be released as the official Gekko 2.0.
  
• R interface. You can export matrices to R, use them there, and import the R results as Gekko matrices. See the commands R_FILE, R_EXPORT, and R_RUN. Since Gekko already allows easy conversion of timeseries into Gekko matrices (and vice versa), you can easily analyze your Gekko timeseries in R. (Strings and scalars will become transferable soon).
• Seasonal adjustment of quarterly or monthly data with X12A. See the command X12A, with many parameter possibilities.
  
• LINK has been renamed to DOWNLOAD.
• You can use SERIES ? to see what kinds of series reside in all open databanks (including their frequencies).
• TRANSLATE command translates files from Gekko 1.8 or AREMOS to Gekko 2.0. The translators are not just string substitution: they use some intelligence to try to figure out how to best translate. The Gekko 1.8 translator is probably reasonably comprehensive, whereas the AREMOS translator deals with much of the tedious stuff, but does not deal with AREMOS specialities or special options.
• AREMOS translator: it is the intention to let this translator evolve, building upon practical experiences. So stay tuned for improvements!
• Gekko will use the Gekko 1.8 translator to provide suggestions in the interactive interface, if it seems that you are entering a command in Gekkko 1.8 syntax.

• Redesign of READ/WRITE and IMPORT/EXPORT. See the bullets below.
  
• READ now only accepts .tsdx files, use IMPORT for other formats. You can use "READ filename TO bankname;" to put the .tsdx file into a stand-alone databank (use "TO *" to replicate the filename as bankname). So the READ command now suppports some of the OPEN functionality. NOTE: READ (without TO) loads the data into the primary databank (without merging), and creates the secondary databank as a ncopy afterwards. . If you need to emulate READ, you should use for instance "CLEAR<prim>; IMPORT<xlsx>data; CLONE;".
• WRITE only writes .tsdx files.
• IMPORT is like READ for non-tsdx files. You can use "IMPORT filename TO bankname;" to put the file into a stand-alone databank (use "TO *" to replicate the filename as bankname). So the IMPORT command now suppports some of the OPEN functionality. NOTE: IMPORT (without TO) merges the data into the primary databank. If you need to emulate READ, you should use for instance "CLEAR<prim>; IMPORT<xlsx>data; CLONE;".
  
• EXPORT only writes non-tsdx files.
• You may use '?' on more variable types. For instance VAL ?, STRING ?, NAME ?, DATE ?, LIST ?, MATRIX ?. Also, this is possible: VAL ? %v, STRING ? %s, NAME ? %n, DATE ? %d, LIST ? #l, MATRIX ? #m.
• CLEAR<prim>, CLEAR<sec> are possible, clearing the primary or secondary bank. CLEAR without options will clear the Work and Base databanks, regardless of their positions in the databank list. In addition, you may use "CLEAR mybank;" to clear a particular named databank (including Work and Base). Note that in Gekko 1.8, CLEAR has the same functionality as RESTART in Gekko 2.0, and CLEAR<all> in Gekko 1.8 has the same functionality as RESET in Gekko 2.0.
• The logic regarding ENDO/EXO has been changed. In Gekko 1.8, setting ENDO/EXO goals would always be enforced, until an UNFIX was issued. In Gekko 2.0, ENDO/EXO goals will only be enforced with SIM<fix>. If you use normal SIM, no ENDO/EXO goals will ever be enforced, even if they are set. So in Gekko 2.0, you have to use SIM<fix> whenever you want the goals to be enforced, but as soon as you do not want them anymore, you can just switch to normal SIM. The reason for the change is that users tend to forget if goals are enforced, so it is better to be explicit about it. To emulate Gekko 1.8 behavior, you can just change all SIM to SIM<fix>, and things will work like in Gekko 1.8, including how UNFIX interacts with simulations. (In Gekko 2.0, the use of UNFIX is more limited than before, because after a SIM<fix>, you can drop the goals by just using a SIM instead of UNFIXing).
• You can use SIM<static> as a local option (or use the global option OPTION solve static = yes). The option can also be <static=yes> or <static=no>. The static option means that lagged endogenous variables are never solved values, but always databank values.
• Regarding IMPORT<tsd>, all values numerically < 1.0e-37 are set to 0. This is because numbers in single-precision software packages (like AREMOS) become very imprecise around that limit.
• Models: you may now use [-1], [-2], ... as lag instead of (-1), (-2), ... The soft lag parentheses will still be allowed in models, for the time being.
• You can use the function miss() to indicate a missing value. Useful in SERIES, SERIES, VAL.
• UPD with $ operator works again.
• INFO command changed to DISP<info>. No need to have separate INFO command, only used with SIM and failsafe option.
• RESET and RESTART did not remove the model: this is fixed.

• WPLOT/CPLOT work again. They had been defunct, because the PRT command internals were completely redesigned. But now they work, but they've godt new names: SHEET and CLIP. So "SHEET x, y;" opens up a Excel with these variables shown, whereas CLIP does the same thing, but sends the output to the clipboard for pasting.
• PPLOT has been renamed to PLOT.
  
• The SHOW statements now prints out a label/explanation (either the expression itself or a given label). For instance, "SHOW #m;" will print out '#m' as label, whereas "SHOW #m 'Experiment 1';" will print out 'Experiment 1' as label.
• You can now (again) use left-side functions in SERIES, for instance "SERIES dlog(y) = ... ;". Legal left-side functions are log, dlog, pch, dif and diff (the last two are synonymous).
  
• More sensible errors reported when a function either does not exist, or is called with the wrong number of arguments.
• Fixed a bug related to timeseries, when these had a stand-alone minus, for instance "PRT -x;".
• Using "PRT [*];" where only 1 item matched did not return the name of the item. This is fixed. Also, when "PRT [*];" returns 0 elements, this is reported.
• There are some potential parsing issues regarding for instance [2*3] and [a*3]. The first one can be use to define a 1x1 matrix, MATRIX m = [2*3], whereas the second one should be understood as matching this wildcard, for instance PRT [a*3] which will find timeseries starting with 'a' and ending with '3'. To a human, this is not confusing, and it would never be possible to interpret MATRIX m = [a*3] as a 1x1 matrix, since a timeseries a could never produce a scalar unless indexed like a[2015]. But this confuses the parser, but it seems the issue is ok now, with some parser workarounds.
  

• The major new improvement in this version is a new way of solving with forward-looking expectations, to supplement the existing Fair-Taylor algorithm that may sometimes get stuck iterating without seeming to do much progress. To solve such 'difficult' simulation problems, so-called stacked time (a Newton variant) has been tried, and it works fine for smaller models. But for large models, the stacked time Jacobi matrix becomes really large and time-consuming to invert. So instead of the stacked time solver, a new framework is proposed, building upon the Fair-Taylor algorithm. This solver is called Newton-Fair-Taylor (or 'nfair'), and it works well, particularly for models without too many variables that contain leads. It has the same theoretical solving capabilities and precision as a 'real' stacked time solver, but the Jacobi matrix is only of dimension (k*n) x (k*n), where k is the number of variables with leads, and n is the number of time periods. The Newton-Fair-Taylor algorithm is not documented in the help files yet (will be done soon), but for now you can switch it on by simply setting this option: "OPTION solve forward method nfair;". In the coming weeks, the algorithm will be tested and fine-tuned, but already now it should be a great deal more reliable than the standard Fair-Taylor algorithm, also for large models and large samples.
  
• Fixed at bug that meant the you could not use PPLOT with more than 6 variables at a time.
• Fixed a bug related to matrices, when these had a stand-alone minus, for instance "SHOW -#m;".

• MATRIX functionality. Quite a lot of matrix stuff implemented, and more to come.
  
  • Ones and zeroes: "MATRIX c = ones(5, 1);", or "MATRIX z = zeros(5, 1);". You may also use zeroes() instead of zeros().
  • Construction: "MATRIX x = [1, 2 || 3, 4];". This is a 2x2 matrix with 1 and 2 in the first row, and 3 and 4 in the last row.
  • Concatenation: "MATRIX x = [#a, #b || #c, #d]. The sizes of the matrices on the right hand side must conform to each other. So the ',' is used to concatenate row-wise, and the '||' is used to concatenate column-wise.
  • Printing: "SHOW #a;". The PRT and DISP commands are oriented towards timeseries, so a new command here makes sense.
    
  • Addition: "MATRIX a1 = #a2 + #a3;".
    
  • Subtraction: "MATRIX a1 = #a2 - #a3;".
  • Multiplication: "MATRIX a1 = #a2 * #a3;". If one of the factors is a VAL or 1x1 matrix, all the elements of the other matrix are multiplied with this scalar.
  • Division:"MATRIX a1 = #a2 / %v;". This is only possible if the denominator is a VAL or 1x1 matrix, in which case all the elements of the first matrix are divided with this scalar.
  • Transpose: "MATRIX a1 = t(#a2);".
  • Identity matrix: "MATRIX m = i(5);". This constructs a 5x5 identity matrix.
  • Indexing: "VAL x = #a[2, 1];". If #a is a nx1 matrix, you can use #a[2] instead of #a[2,1]. This shortcut only works for such column vectors, not 1xn row vectors.
  • Sub-matrices: "MATRIX x = #a[1..2, 5..7];". This will pick out rows 1, 2 and columns 5, 6 and 7, resulting in a 2x3 matrix. If you omit the first part of the range, the first row is assumed. Likewise with the last part of the range, so if if the matrix #x has 7 columns, you can use #a[..2, 5..]. Using #a[.., ..] will return #a itself!
  • You may combine selections with fixed rows/columns, for instance #a[2, ..] to select the full second row, or #a[.. , 3] to select the fulle third column.
  • For column vectors, you may use #a[2..4] to select rows 2, 3 and 4 from that vector. It is implicitly translated into #a[2..4, 1].
  • Packing/unpacking from timeseries to matrices. To pack the timeseries x, y and z into a matrix #m, use "MATRIX m = pack(2015, 2020, x, y, z);". The rows will be the 6 periods, and the columns will be the 3 timeseries. To unpack the timeseries y again (with the new name ynew), use "CREATE ynew = unpack(2015, 2020, #m[.., 2]);", using only the second column of matrix #m. When packing and unpacking, the time period and matrix dimensions must conform. If you omit the time period, the pack() and unpack() functions will use the current time period.
  • Element-by-element multiplication and division: "MATRIX m = multiply(#m1, #m2);" and "MATRIX m = divide(#m1, #m2);".
  • Matrix inverse: "MATRIX m2 = inv(#m1);". The function will fail if the matrix is singular or non-symmetric.
  • Matrix determinant: "VAL v = det(#m1);". The function will fail if the matrix is non-symmetric.
  • Diagonal: "MATRIX m2 = diag(#m1);". If #m1 is a n x n symmetric matrix, the method returns the diagonal as a n x 1 matrix. If #m1 is a n x 1 column vector, the method returns a n x n matrix with this column vector on the diagonal (and zeroes elsewhere).
    
  • Trace: "VAL v = trace(#m);" computes the trace of the matrix (the sum of the diagonal elements).
    
  • Sum, average, min, max. The functions sumr(), avgr(), minr() and maxr() performs these calculations on the rows of the matrix, whereas the functions sumc(), avgc(), minc() and maxc() performs these calculations on the columns.
  • Rounding: "MATRIX m2 = round(#m, 2);" will round each element in the matrix to two decimals.
  • In addition, you may also use log(), exp, and abs() on a matrix. This will perform the transformation on each element.
    
• Labels are fixed in PPLOT, regarding quarterly and monthly data. An 'intelligent' labeling system is employed, trying to show not too many or too few labels.

• You can now use GOTO and LABEL. For instance, inside a loop you may have this line: "IF(%x > 10); GOTO lbl1; END;", and after the loop you may have the statement "LABEL lbl1;". In that case, when %x is > 10 inside the loop, the remainder of the loop is skipped. (Please note that LABEL is called TARGET in AREMOS).
• Reads .tsd files with variable labels, if these labels are positioned in position 17 and onwards (after the variable name, which is assumed max 16 characters long). Gekko issues an error if a variable name is malformed (for instance contains blanks etc.).
• With frequency set to for instance quarterly, you may now use integers, for instance "TIME 2015 2016" or SERIES<2015 2016>... In that case,  the period is set from 2015q1 to 2016q4, so the quarters are set implicitly.
• Fixed DISP with non-annual frequency. It simply printed out the dates wrongly.

• Possibility of using LIST<direct>, for lists where the names can be integers or name parts starting with integers. For example, "LIST <direct> n = 117, a38, 007;". Without the <direct> option, quotes around these elements would be mandatory: "LIST n = '117', 'a37', '007';". The <direct> option is practical for long comma-separated lists containing such name parts.
• READ<prn> and WRITE<prn> is possible. The first item (the 'cell' in row 1, column 1) should be either 'name' or 'date' to indicate whether the  first column contain names or dates. (The prn format resembles the csv format quite a lot, but the data are separated by blanks rather than semicolons).
  
• UPDPRT has been fixed: the trailing semicolons were missing.

• The changes are minor, mostly changes to conform with the latest version of the syntax blueprint.
• (Under the hood, a lot has been changed to prepare for the upcoming stacked newton solver).
  

• Quite a lot of bugfixes and improvements.
• AREMOS-like logic enabled regarding OPEN<prim>. Gekko now implements a databank list, where the first databank (primary) is often Work, and the second databank (secondary) is often Base. But this may be changed by means of OPEN<prim> and OPEN<sec>, and multipliers etc. will now relate to the <prim> and <sec> databanks, and not necessarily to the Work and Base databanks. When an OPEN<prim> databank is closed, the contents are written back to the databank file. OPEN<prot> is also possible, to protect a databank from being altered. The F2 window is altered slightly to reflect the primary/secondary logic.
• New option "OPTION databank autocreate = yes|no" and "OPTION databank search = yes|no". Autocreate will create any timeseries stated in for instance the left side of a SERIES command (emulating AREMOS). Search will enable databank search (again emulating AREMOS), so that variables/timeseries are looked up in the databanks in the order they are listed (cf. the F2 window). Setting these two options is practical regarding databank revision programs.
  
• Similarly to OPEN<prim> or OPEN<sec>, you may also use "READ<prim>bank" or "READ<sec>bank". The latter replaces the "MULBK bank" command. Note that "READ<prim>bank" only reads into the primary bank, whereas "READ bank" reads into both the primary and secondary databanks. (The old MULBK without an argument is now called CLONE).
  
• Command files are now expected to have extension .gek, so "RUN prg;" will look for prg.gek. Older .cmd files or other extensions must be called with explicit extension (for instance: RUN oldfile.cmd).
• Gekko will no longer look for an isstart.cmd file to auto-run when Gekko starts up: only gekko.ini files can be used for that purpose.
• CLEAR and CLEAR<all> for clearing the workspace are now replaced with RESTART and RESET commands, respectively. The CLEAR command is now only used for clearing particular databanks like "CLEAR bank;". RESTART will run any gekko.ini file, so think of the command as resetting and starting the gekko.ini file (hence the name).
  
• Parallel FOR loops possible (for string loops), for instance "FOR (i = a, b, c  j = x, y, x); PRT k{i}{j}; END;". This will print the timeseries kax, kby and  kcx. The parallel loop may run more than two lists in tandem, if needed.
  
• Percentile() function: "VAL p = percentile(gdp, 0.25)" will calculate the 25% percentile of all the values in the timeseries gdp (missings are ignored) over the global sample set by the TIME command.
• Sqrt() function.
• Format() function that formats a value corresponding to a given format. For instance: "TELL 'Value is: ' + format(%v, '.000');". This will show %v with 3 decimals. You may use '.###' instead to suppress any trailing 0's in the value.
  
• Sum() function that sums comma separated items, for instance "SERIES x = sum(a, b, c);" or "SERIES x = sum(#m1, #m2);", where #m1 and #m2 are lists of names. You may sum any number of items, including only one.
  
• COPY command can be used with COPY<from = ...  to = ...> to denote the databanks that the variables are copied between. So you may use "COPY<from = bank1  to = bank2> #m;" to copy the timeseries in the list #m from the databank bank1 to the databank bank2. Also COPY ... TO ... is possible, where wildcard '*' can be used, for instance "COPY bank2:a* TO bank1:*;". This copies all timeseries beginning with 'a' in bank2 to bank1.
• Augmented the command FINDMISSINGDATA with a <replace = ...> option, for instance: "FINDMISSINGDATA<1980 2010 replace = 0>#m;". Here, any missing values in the timeseries in #m are replaced with the replace-value 0. If using the replace option, lists are not generated.
  
• UPD with rep = ... possible, for instance "UPD <2015 2050> x = 10 rep 5, 7 rep 4, 12 rep *;". The last "REP *" fills out the remainder of the sample. So the result is x = 10, 10, 10, 10, 10, 7, 7, 7, 7, 12, 12, ...  12. (The last 12 is in 2050).
  
• Putting a simple scalar inside a string is possible, for instance STRING s = 'My name is %s', where %s = 'Jones'. This is more convenient to write compared to the equivalent STRING s = 'My name is ' + %s.
  
• PPLOT fixed, so that the user can now again click for percentages etc. Note that when clicking, Gekko loads new data from the databanks, so any changes will be reflected in the graph (Gekko 1.8 could show percentages etc. on the original data, but this practice is discontinued). In most cases, this difference is academic.
• In PPLOT, you may scale the y axis: for instance PPLOT<ymin = 50 ymax = 200> x1, x2;
• READ <tsp> and WRITE <tsp> are now possible, reading and writing output from a TSP program in a particular format. Since both reading and writing of TSP files is possible, interfacing to TSP can be done with the SYS command and Gekko as a 'host' environment.
• Printcodes 'b', 'bn', 'bd', bp', 'bdp' are changed to 's', 'sn', 'sd', sp', 'sdp', since the background/multiplier bank does not necessarily have the name 'Base', but is now the secondary databank (hence 's' instead of 'b'). So to print for instance percentage growth in the secondary databank, use PRT<sp> instead of PRT<bp>.
  
• Databanks are compressed after reading from file, so they use less RAM. Reading .tsd files improved regarding RAM, too (so much larger .tsd files can be read).

• This version is the first release in the 2.0 series. Gekko 2.0 marks a significant shift in syntax and capabilities, providing a richer environment for programming, data handling, data revision programs, etc. The changes relative to the 1.8 series are too numerous to list here (see the 'New features' list in the Gekko 2.0 help file).
  

• This version is identical to 1.7.5, except for the version number.

• This version is leading up to a stable version 1.8 release.
  
• Conversion of .prn files to .csv files. The two file types are quite similar: the main difference is that spaces are delimiters in .prn files, whereas semicolons are delimiters in .csv files. Additionally, .prn files tend to be with the timeseries running downwards, whereas .csv files often have timeseries running outwards. Convert with "CONVERTPRN myfile", where myfile.prn is a .prn file. A myfile.csv file will be produced, and this .csv file can be read by means of "READ <csv cols merge> myfile". In the longer run, a READ<prn> will probably be done, but for now you may use the converter. See the help file under CONVERTPRN for more details.
• List files: You may use "LISTmylist = #(listfile myfile)", where the external file myfile.lst has an item on each line (extension .lst will be added to the filename as default). As of now, listfiles may only be used as in this example (i.e., in the LIST command), and not in PRT and other commands. This limitation will be relieved of course.
• Font sizes on the three tabs in the main window can be set with "OPTION interface zoom = x", where x is an integer (%). If set to 100, there is no zoom, and if for instance "OPTION interface zoom = 120", the fonts will be 20% larger. If you accidentally set the zoom level to something nonsensical and have problems correcting this, just close and restart Gekko.
• F2 window now shows all metadata when opening PCIM databanks.
• A warning regarding PCIM databanks has been suppressed (for instance: "1 variables with empty string as name in PCIM bank (skipped)"). This is nothing to worry about, so the warning has been turned off.
• Small change regarding Z-variables. If a model Z-variable does not exist when the databank is read, older Gekko version would create the variable and set it's values to NaN (missing). This has been corrected, so that the values are now set to the corresponding variable. For instance: if the variable Zphk does not exist, it will be created and filled with values from the corresponding phk variable.
• Bug: loading a cached model will now show the correct file name.
• Tables (html): minus was shown as a non-breaking hyphen (with a special html code). This has now been corrected to a regular minus, so that copy-paste via right-clicking the table is more sensible. But in general, please use the Gekko Copy-button for copy-pasting tables.
  
• If the cursor is located in the upper part of the split main Gekko window and you start typing, Gekko will shift the focus to the lower (input) window. This only works regarding chars from a-z or 1-9.
  
• The help files have been updated.

• PPLOT has a possibility to graph variables from Work and Base databanks in a convenient way, for instance: PPLOT<a> fY, where 'a' can be read as 'all'. This will plot the variable fY from both banks. You may also use PPLOT<ap> for percentage plot, and PPLOT<ad> for time differences. The 'a' print code only works for PPLOT at the moment, but will be fully integrated in PRT, WPLOT etc. in the 2.0 series. Note that "PPLOT<a> fY" is functionally equivalent to "PPLOT fY @fY".
• Graphs may have point indicators omitted by means of: OPTION graph lines points = no.
  
• In html tables, the width of columns has been fine-tuned. You can now use "option table html datawidth", "option table html firstcolwidth", and "option table html secondcolwidth". These default to 5.5, which is approximatively 5.5 characters, but can be augmented to provide more spacing. The options firstcolwidth and secondcolwidth are used to adjust the width of the first and second column: these typically contain labels (first column), and possibly variable name (second column). Note that these widths are minimum widths, so if a particular cell is larger than that, the whole column will adjust to contain the cell. Another way of stating this is that text and numbers are never truncated in html tables. So to make different tables align regarding columns, you may have to finetune the column widths.

• Some refinements regarding tables, for instance it is possible to add a gray vertical border between two particular periods. For instance: <col type="expand"> <subcolborder period="#sub1"/> </col> will insert a gray vertical border after period #sub1 (where scalar variable #sub1 is expected to be a date -- you might also use period="2020" to hard-code the period). Note: in general, tables now accept scalar variables inside strings.
• PPLOT can now export in .png or .svg file formats, too. For instance "PPLOT fY fX file=fig1.png" will produce the file fig1.png with the graph. Default format is still .emf, so "PPLOT fY fX file=fig1" will produce the file fig1.emf. The .png and .svg formats are convenient for html web pages (note: the .png format may lose some precision, since it is raster/pixel-based).

• Introduced fixed parameters in the model (.frm) file. These may be indicated like this: "FRML _i  y = #c * x;". The parameter #c must be defined with a VAL statement somewhere in the .frm file: "VAL c = 0.82;". The parameters will be in-substituted when compiling the model, so there is no speed penalty and the equation will run just as fast as "FRML _i  y = 0.82 * x;".
• Reading from Excel is now possible. Use READ<xls> or READ<xlsx>. The <xls> or <xlsx> option also works with MULBK or OPEN. For now, the Excel workbook should only have one sheet, and the first row should be dates, whereas the first column should be variable names (you may use READ <xlsx cols> if you need to read data that has variables in columns (transposed)). The same is now possible regarding .csv files: READ<csv cols> etc.
  
• Introduced a new frequency 'undated' alongside annual, quarterly and monthly: use "OPTION freq u". The undated frequency works much as annual, but may more conveniently start at observation 1 (or 0 if preferred). It has for instance been used to simulate a hourly electricity model, on the period 1-8760 (which is the number of hours in a non-leap year). With 'undated' frequency, the lagged value of variable x in period 100 (that is, x(-1)) is the value of variable x in period 99. So in this sense, 'undated' works like 'annual'.
  

• Fixed problems with adding VAL and STRING, or DATE and STRING. "VAL v1 = 1; STRING s2 = '2'; VAL v = #v1 + #s2;" Gave v = 21, should be 12. "DATE d1 = 1990; STRING s2 = '2'; VAL v = #v1 + #s2;" Gave v = 21990, should be 19902. This is now corrected.
• Function pow(a, b) did not work: is fixed. Also, you can now use '^' as power function together with '**'. So x**0.5 and x^0.5 and pow(x, 0.5) are now all legal.
• New HP-filter function: hpfilter(). Use for instance like this: "GENR <2000 2012> xxgdp_hp = hpfilter(gdp, 6.25);". The 6.25 is the lambda parameter, recommended to be 6.25 for annual, 1600 for quarterly, and 129600 for monthly data (see here). You may include one more parameter that should be 0 or 1. If 0, raw data are used. If 1, log() is taken on the input values before the HP-filter is computed, and exp() is taken before the values are returned. Setting this parameter to 1 may thus make more sense regarding growth variables, since the HP calculation is performed on log levels (do not set to 1 for variables that may become 0 or negative). You may use assign-variables for the lambda and log arguments.

• See this.
  
• Fixed problems with the RETURN statement.
• Fixed problems with adding VAL and STRING, or DATE and STRING.
• Changed convergence settings for forward-looking models. Maybe these settings are better, but needs to be investigated further.
  

• Added "OPTION model cache = [yes|no]" option, to turn off all use of cached models, forcing model parsing on all MODEL statements (like in Gekko 1.4). This is only intended to be used if problems show up regarding model caching.
• A bug regarding failsafe mode was corrected. Some interactions between failsafe mode and cached models meant that failsafe mode would fail with an error. This is corrected now.

• GMULPRT possible to use as synonym for MULPRT<v>. Many users are familiar with GMULPRT, but in the long run it should perhaps be VMULPRT then...
  

• Table searching logic redone. Added more table folders: OPTION folder table/table1/table2.
• Introduced 'Home' button on user interface. When in the Menu tab, the button will restart the Menu system. When in Main tab, the button will go back to the first DISP command, if DISP is used for equation browsing.
  

• "OPTION table startfile" changed to "OPTION menu startfile".

• Help file: if "OPTION interface_help_copylocal" is set, Gekko will copy the gekko.chm file to a location on the user's hard disk before opening it up. This eliminates some problems regarding opening up such files from a network drive.

• Decomposition window (UDVALG) can show decompose and data errors. Percentages are shown with 2 decimals instead of 4.
• Some options to control html tables (see "OPTION table html...").
• Suggestions can only be applied for OPTION commands. Using them for other commands proved too buggy. The suggestion system will be reconsidered, but for OPTION commands it is quite helpful.
• In addition, some minor bugfixes.

• Only minor changes relative to 1.5.12.

• Updated help files, and a number of smaller bugfixes.
• Fixing issue with "MULPRT jul05:fy", where 'jul05' is a named databank opened by means of the OPEN command. This print will now correspond to "jul05:fy - Base:fy" (which is the most logical: earlier versions would print out "jul05:fy - jul05:fy" which is always 0...).
• "LIST ?" produces more readable/unfoldable output when a model is loaded.

• Reordering of equations when doing Gauss simulation is switched off as default (OPTION solve gauss reorder = no). Theoretically, reordering should reduce the number of Gauss iterations used, but in practice setting the option to 'yes' can yield annoying starting value problems. So better to switch the reordering off as default. In rare cases, this change may imply that some models that used to solve with older Gekko's will no longer solve (in that case, try to set "OPTION solve gauss reorder = yes" and see if the model solves again). Or use the Newton solve method instead (it is more powerful).
• Default databank format is now tsdx. The option controlling this (OPTION databank file format) has been changed from tsd to tsdx, so when typing "READ mybank", Gekko will now look for the file mybank.tsdx, whereas older Gekko's would look for mybank.tsd. So you may need to change existing "READ mybank" statements to "READ <tsd> mybank" (or set "OPTION databank file format = tsd"). The tsdx format will be used in the future, and some safety measures have been implemented as a result of this default format change. For some time onwards, you may now not READ a 'mybank.tsdx' file by means of "READ mybank", if there is a 'mybank.tsd' file available in the same folder. In that case you will get an error, so that the possible ambiguity can be resolved. The remedy to this error is to (re)move or rename the .tsd file, or alternatively explicitly indicate which file you intend to use (for instance "READ <tsdx> mybank", or by explicitly setting the databank format beforehand: OPTION databank file format = tsdx). These measures may seem cumbersome, but better safe than sorry (it would be very bad to accidently read mybank.tsdx when really mybank.tsd was intended).
• New logic regarding swapping of databanks. Swapping is intended for being used to quickly compare three or more databanks (for instance different scenarios etc.), and swapping is done in the F2 window, by dragging the databanks. When databanks have been swapped, Gekko will enter 'swap-mode' where only viewing (but not altering) data is allowed. In this mode, you may use PRT/MULPRT/WPLOT/PPLOT/UDVALG and similar commands, but no UPD/GENR/READ/WRITE/SIM etc. To exit swap-mode, simply type UNSWAP, or click the unswap button in the F2 window.
• Suggestions in the user interface. This was available in some very old Gekko versions, and has been revived. Gekko will pop up a small window with available keywords when selecting options (OPTION command) or typing '<' to set options in a local option field. There is an 'OPTION interface suggestions' that is set to 'some' as default. Other possibilities are 'none' (no suggestions) or 'all' (suggestions in all places). Suggestions still need some improvements, but is intented to alleviate the need for looking up syntax in the help files. To use a suggestion, either double-click it, or select it and type [Enter]. You may force the suggestion popup to open at an arbitrary location by means of Ctrl + Enter.
• Recording of commands. Gekko remembers all command issued in the command window, and these can be seen (and possibly copy-pasted to a command file) from the menu 'Edit' --> 'Command history...' (and cleared via the 'Clear command history' menu item). The command history is automatically cleared at Gekko startup, or after clearing of workspace (CLOSEALL). The command memory can be practical for reproducing a particular Gekko session (i.e. sequence of commands). The 'recorded' commands can either be executed as a block of commands in the command window (paste them, and mark them before hitting [Enter]), or alternatively put them in a command file and execute them by means of a RUN statement. (Note as a curiosity that calling a command file ("RUN myfile") will wipe out the history of its own call, if the command file contains a CLOSEALL statement).
• FOR loops improvements. Loops now work on strings, values or dates (FOR used only to work on strings). For values, you can use "FOR val v = 1 to 100 by 2" to get a secuence of values (1, 3, 5, ...) whereas for dates you may use "FOR date d = 2000q1 to 2005q4 by 2" to get a sequence of dates (2000q1, 2000q3, 2001q1 etc.). Note that you have to use "FOR val" and "FOR date", so that the scalar variables #v and #d have their type indicated. This is to avoid confusion (for string type, the type may optionally be omitted, so you may use "FOR string s = a b c" or the equivalent "FOR s = a b c").
• CLEARGOALS and GAUSS removed: the new command UNFIX should be used instead (also OPTION solve gauss goal switchback has been removed). A new logic is used instead of this: When simulating with goals (ENDO/EXO), if the solve method is set to "gauss", Gekko will temporarily use the Newton algorithm to solve with goals. But if the goals are removed (UNFIX), Gekko will revert back to whatever method (typically Gauss) was used to solve the model without goals (former Gekko versions switched permanently to the Newton method when doing goal search). The UNFIX is simply equivalent to an ENDO and an EXO command (clearing these lists).
• IF statements improvement. IF is now working with OR, AND and NOT, and with comparinsons '<', '<=', '==', '>=', '>', '<>'. If statements can be used with scalar variables (strings, values or dates) or individual timeseries observations  (for instance 'variable[2010]'). If you need to change a type into another type in order to compare them, you may need so-called casting. This can be done via the methods string(...), val(...) and date(...) which try to convert from one type to another (for instance from the value 2010.0 to the date 2010 or vice versa). There is also an exist(x)-function that returns 0 or 1 depending upon whether the timerseries 'x' exists in the Work databank.
• WRITE<csv> and WRITE<xls> now work for quarterly and monthly frequencies, and READ<csv> (and MULBK<csv> and OPEN<csv>) is supported, too. So interfacing with a spreadsheet like Excel should be a little easier.
• Laspeyres chain index function. Use for instance GENR (p,x) = laspchain(#p,#x, 2005), where #p is a list of prices, and #x is a corresponding list of quantities (the two lists multiplied together should provide the total costs of the quantities). An index period needs to be indicated (here 2005), and the resulting price index series (p) will be 1 in that period. You may alternatively use laspfixed(...) to get indices using fixed prices (fixed as the values in the period indicated).
• Updating or closing all PPLOT or UDVALG windows. This can be done from the 'Window' menu.
• Copy button. This button in the toolbar in the user interface copies the 'cells' from the last PRT/MULPRT statement to the clipboard (tab-separated). In this format, they can be pasted into a spreadsheet (e.g. Excel), or into a word processor like Word. But the primary function is spread-sheet pasting. Note that the number of decimals (or width of columns) will be lost when doing such copy-paste. The functionality is similar to the CPLOT command (which is in reality putting a WPLOT into the clipboard).
• Change of INI file name. In the future, command files that are to be run when doing CLOSEALL or at Gekko startup should be called gekko.ini instead of isstart.cmd. Using the name isstart.cmd will still work for some time though.
• GMULPRT has been renamed to MULPRT<v> ('v' for 'verbose'). You can also set "OPTION print mulprt = v", and in that case all MULPRT statements will be issued as MULPRT<v> if this is preferred. Putting a <v> option in MULPRT overrides any other local print options in that option field.
• "CLEAR all" command. This command works like a CLOSEALL, but without loading the INI file (gekko.ini/isstart.cmd). This command was named 'NEW' for some period, but "CLEAR all" seems more logical (like in Matlab for instance). Also, you may use "CLEAR" which is equivalent to CLOSEALL. In the longer run CLOSEALL will disappear, and there will be two and only two clearing commands: "CLEAR" (used normally and typically loads a model and databank) or "CLEAR all" (for a completely clean state). The two will be equivalent in the absence of an gekko.ini or isstart.cmd file in the working folder.
• NYTVINDU command is obsolete: use CLS.
• UNDO SIM is also obsolete (when simulations fail, you can instead click a link to undo the simulation).
• Function pow(a,b) is supported (same as a**b or a^b).
• When simulating with goals, Gekko will print the number of goals used (so there is less room for misunderstanding regarding whether the model is 'fixed' or not).
• Commands FLAT, ZERO, DUMON and DUMOF will be removed at some point. At the moment they still work, but a warning is issued, and alternative syntax is suggested (UPD [*] % 0, UPD [*] = 0, UPD dummy = 1, UPD dummy = 0).
• Commands ENDOGENIZE and EXOGENIZE have been removed (use ENDO and EXO insted, to reduce your risk of carpal tunnel syndrome).
• IF can now only use '==' and not '=' to test for equivalence (for instance IF(#v == 10) or IF(#s == 'abc'). This is consistent with AREMOS and many other languages.

• Numerous changes in this version.
  
• Run status window for tracking larger jobs. Open it from the 'Utilities' menu, or dobbel-click the traffic lights in lower right of the main Gekko window.
  
• TIMEFILTER command has been changed from being 'negative' (choosing periods to be filtered out) to being 'positive'. For instance, "TIMEFILTER 2010, 2012, 2014" will filter out the years 2011 and 2013 (and show all other years). Ranges can be used: "TIMEFILTER 2010:2014 by 2" has the same effect. A timefilter is switched on and off by means of "OPTION timefilter = yes|no", and its type can be set with "OPTION timefilter type = avg|hide". Option 'hide' here just out-filters the periods, whereas 'avg' averages up the missing periods. The options can be used locally, for instance "PRT <filter>..." or "PRT <nofilter>", or PRT <filter=hide>..." or PRT <filter=avg>...". By using the 'avg' filter, you get the same functionality as the VPRT command. In the above example, a "PRT<filter=avg>..." would show the average of 2011 and 2012, and the average of 2013 and 2014.
• TELL command. Used like this: TELL 'Hello' (or TELL <nocr> 'Hello' to omit carriage return). Will replace the DISPLAY command in the longer run.
• PIPE can pipe to html files, too. Use "PIPE <html> filename" or "PIPE <html append> filename". When piping to html, you can use the TELL command: for instance "TELL '<p>Hello</p>'. As you see, you need to remember the html tags when adding to a html file. The funtionality will be useful when producing tables in html.
• Model blocks supported. In a .frm file, a line like "// ### Consumption ###" can be used to indicate that the next block of equations is the 'Consumption' block. This block info is showed in the DISP command, and can be optionally used for residual check (Utilities --> Residual check...").
• UPDX and UPD are merged: so now there is only UPD.
• "LIST mylist = null" supported (yields an empty list). Also, you may now put integers as items in a list: for instance "LIST mylist = 0  01  57e".
• Loop improvements, more on this when FOR and IF statemens are matured fully.
• PRT and MULPRT wrap in case of many variables (didn't work in 1.5.9).
• Now 'exp' and 'log' are function keywords, so Gekko allows for instance exp(-1.5) or log(2.5) etc. in models and expressions (will no longer think 'exp' is a variable).
• Truncated "WRITE <per1 per2>" did not work in 1.5.9: fixed.
  
• Parser change, so that stuff like "VAL y = x" is no longer valid: must be "VAL y = #x"
• Numerous other small changes and fixes, all pointing towards a version 1.6.

• The version merges the PRTX command with the old PRT command (and removes PRTX completely). In addition, PCTPRT and MULPCT are removed (replaced with PRT<pch> and MULPRT<pch>). PRT and MULPRT can now be called with 'long' display codes, such as 'lev', 'abs', 'dif', 'pch', 'gdif' (the last one is growth differences).
• Multiple display-codes are legal in the same <>-field: for instance "PRT<dif pch> fY" or MULPRT<lev pch> fY. (These are equivalent to "PRT<d p> fY" and "PRT<n q> fY" using short display codes).
• Long display codes are hopefully easier to remember and are of the form <code={yes|no|append}>. If 'yes', it will only show the chosen code, whereas if it is 'append' it will add the code to the default codes. If 'no', the particular code is not shown. The defaults are set in "OPTION print prt ..." and "OPTION print mulprt ...". Also, field width and number of decimals can be set globally: see "OPTION print fields ...".
• In general, the 'yes'/'no'/'append' can be abbreviated, so for instance <pch=yes> can be written as <pch>, whereas <pch=no> can be written as <nopch>, and <pch=append> can be written as <_pch>. The underscore can be thought of as a glue character, indicating that the code is to be added to the existing codes.
  
• As before in PRTX, display codes can be set either after PRT/MULPRT, or alternatively element-specific after the specific variable/expression/list/wildcard. So this is possible: "PRT<abs> fY fX fE<pch>". Then fY and fX will be absolute values, whereas the <abs> is overridden with <pch> as regards fE (which is shown in percentage growth).
• As in PRTX, it is possible to transpose the result (variables running downwards). Use PRT<rows> for that.
• In case of a memory/RAM error, Gekko will include a list of active processes in the error message.

• Menu folder: OPTION folder menu = [foldername]; Before, the location was the same as for tables (OPTION folder table), but now the two are separated, so that tables and menus can reside in separate folders.
• Faster loading of models. The first time a model loads (MODEL statement), it loads with the 'old' speed. But the next and following times, the model will load much faster, since much of the model parsing information is now stored in a cache file. So if a model is known, Gekko will use the cached information instead of chewing on the same model once again (models are distinguished by means of signatures, see below). The cache file is stored in a temporary folder, and Gekko will try to avoid that this temporary folder becomes too bulky (by erasing some of the least recently used temp files from time to time). (Note by the way that the first simulation (SIM) after a model statement (MODEL) takes a bit longer time, because of some behind-the-scenes warmup of the compiler. Following SIMs run at full speed). The cachefiles are so-called protobuffer files, i.e. the fast binary file format used at Google and many other places. Using these cachefiles, there is a factor 8 speedup on loading an ADAM-type model.
  
• Faster databanks. In Gekko 1.5.7 and before, the .tsdx file format consisted of a 'normal' tsd files (with more decimal places than usual though), and a xml file containg meta-information. These files were zipped, and the resulting file given the extension .tsdx. From version 1.5.8 and onwards, the datacontainer inside the zipped .tsdx file is a so-called protobuffer file, instead of a tsd file. Protobuffers is the fast binary file format used at Google and many other places, and binary files read much faster than tsd files (which are in text format). From version 1.5.8 and onwards, tsdx files are stored (WRITE command) this way. This means that Gekko versions 1.5.7 and earlier cannot read the newer .tsdx files, but versions 1.5.8 and later will read older tsdx files. The information stored in the old and new tsdx files is exactly the same, so there is no loss of information when converting the files from old to new format (conversion: simply READ<tsdx>oldfile; WRITE<tsdx>newfile;). Using the new .tsdx files, there is a factor 3 speedup on loading a large databank. (If the tsdx files were not zipped, the speedup would be a lot larger, since unzipping takes almost as much time as loading the unzipped datacontainer file itself. But then the users would end up with files 5-10 times larger. This is not considered acceptable, but an option for bulky high-speed tsdx files could be provided at a later point). The tsdx databank format in Gekko 1.5.8 and onwards is called version 1.1, and as always with tsdx files, data is stored in double-precision (15 significant digits). When comparing loading speed with PCIM databanks (READ<pcim>), please remember that PCIM databanks are single-precison (8 significant digits), and unzipped.
  
• CLOSEALL speedup. The speedups regarding models and databanks imply that a CLOSEALL with an isstart.cmd file loading a model and databank will perform much faster than before (expect a factor 6-8 speedup). Starting up Gekko with a model and databank will be similarly faster.
  
• Model signatures. Gekko 1.5.8 introduces model signatures, i.e. a kind of check-sum or fingerprint regarding .frm files. The signatures are technically so-called MD5 hashes, and are put into the .frm file as commentaries (for example: "// Signature: fp88RzyZfJNaoTi3I4X3Ww"). This string of characters and digits (note: the hash code is case-sensitive!) identifies a specific model file, so altering the model file will result in a different hash code. The motivation behind the signatures is two-fold: (a) To be able to make sure that an official model version (e.g., a specific ADAM .frm file) has not accidently been changed, and (b) The signatures are used to identify models for caching (faster loading). When calculating the signature (hash code), empty lines and comment lines are ignored, so you may insert full-line comments any way you like in the .frm file and preserve the signature (any variable list after the VARLIST$ tag will be ignored, too). But changing the equations (FRML) in any way will result in a new hash code. The hash code is technically 128 bits, and this means that the probability of two different model files having the same hash code is 2^(-128) = 2.9E-39 (that is, effectively zero). See also the SIGN command below.
  
• SIGN command. This command prints out information regarding the model signature in the model file, and the 'true' hash code corresponding to the model file (and whether they are identical). You can use the SIGN command to obtain  the hash code for signing a new (or changed) model.
  
• Info, Date and Signature in model files. As for databank files (cf. HDG command), you may now put meta-information into the model file (.frm). As of now, Info, Date, and Signature fields are supported. Example:
• // Info: Model used for forecasting 2012-2030
• // Date: 7-11-2012 15:37:00
• // Signature: fp88RzyZfJNaoTi3I4X3Ww
Gekko will complain if this format deviates, for instance the Info field is to be written with capital 'I', with no blank before the colon, and one blank after the colon. This rigorousness regarding form is to make it easy to spot the information in different .frm files. The Info and Date fields will be displayed when loading the model (MODEL command), and the Signature field is used for verifying that .frm files have not been changed relative to an 'official' version.

• Forward looking models can be solved by means of the Fair-Taylor algorithm. The algorithm is still being tested, so please use with a little care. Fair-Taylor switches automatically on with a SIM on a model containing leaded variables. There are a lot of options related to this: see 'OPTION ?', under 'OPTION solve forward...' (or type 'HELP option').
  
• TABLE can provide HTML in addition to text format, if you indicate it with 'TABLE <html>'. If so, the table is shown in the 'Menu' tab. This is still work in progress, and more finetuning of the HTML tables will be done. The table itself can be seen as '__table.html' in the working folder, and can be opened in a browser. From the browser, it can be copy-pasted (Ctrl-A + Ctrl-C + Ctrl-V) pretty intact to Word or Excel.
  
• TIMEFILTER command. This command identifies periods that are to filtered out in output like TABLE, DISP, PRT and PRTX (the commands PPLOT, WPLOT, CPLOT etc. do not react to this filter). The out-filtered periods are simply omitted, and the TIMEFILTER command has the same syntax as the TIMESPAN command. On the annual period 2012-2030, you might use: "TIMESPAN 2016 2017, 2019 2019, 2021 2024, 2026 2029;". This way, the periods 2016-2017, 2019, 2021-2024 and 2026-2029 are filtered out, leaving the years 2012-2015, 2018, 2020, 2025 and 2030. Note that this command only affects how printing is laid out (so SIM, UPD, GENR etc. are unaffected by TIMEFILTER settings).
  
• New OPEN command: opens up a databank that can later be referred to by means of [databank]:[variable], i.e. with a colon. For instance, "OPEN adam" opens the 'adam' databank, and a variable 'fY' can be printed like this: "PRT adam:fY". As before, variables without databank indicator are taken from the Work databank, and variables with '@' indicator are taken from the Base databank. The OPEN databanks can be closed by means of the CLOSE, and you can open a databank with an alias, using the AS keyword: "OPEN adbk2014 AS adam". OPEN-databanks are read-only.
  
• There is a new databanks window that can be opened by means of the 'F2' key. The window shows a list of open databanks, including Work ad Base. The window implements swapping, i.e. it is possible to drag a databank to another position. For instance, dragging an OPEN databank  to the first line in the list will turn it into the Work databank.
  
• The graph window (PPLOT) can now be updated ("Update graph" button) with new values from databanks. So now both the PPLOT and UDVALG windows can be updated, and this will also work if databanks are swapped by means of the databanks window ('F2' key).
  
• COLLAPSE command for transforming higher-frequency data into lower frequency. For instance: "COLLAPSE fY.a = fY.q total" transforms the quarterly fY series into an annual fY series, where the quarters are summed. Other methods are 'average', 'first' (first quarter) and 'last' (last quarter). Transformations from months to quarters or months to annual are also possible.
  
• The UDVALG (decomposition) window now has frozen (non-scrolling) headers regarding variable names and time periods. Also, variables are now clickable/browsable.
• New help system, using a more standard searchable .chm file. The help system can be opened by means of 'F1', or typing HELP in the command line (or choosing 'Help' --> 'Help Contents' in the menu). Also, you may jump directly to the specific command by means of typing for instance "HELP sim" (to get help for the SIM command). Last but not least, the content of the help system is now up to date!
• In the user interface, when writing "READ *", "MULBK *", or "OPEN *", Gekko will replace the '*' with the file name chosen. This makes it easier to rerun the lines at a later point (or copy them to a command file).
  
• An old bug regarding line numbers in error messages is fixed. Before, when a run-time error occurred in a command with no arguments (like for instance SIM or STOP), line number 0 was reported regardless of where the line actually occured in the file.
  
• The 'Menu' tab uses a browser component that seemed to have some problems on some computers (the graphical user interface would not start up at all). The component is replaced, and Gekko should (again) be able to work on any .NET version 3.0 or better (since .NET 3.0 was introduced in 2006, more than 95% of all Windows users have .NET 3.0 or better).
• A bug in relation to the 'colspan' attribute in XML tables has been fixed. When doing a new table row, code like <text colspan="3">AAA</txt> <txt>BBB</txt> should make 'BBB' appear in the fourth column. This is not how it works in versions prior to Gekko 1.5.7, where you would have had to add two "placeholder" elements: <text colspan="3">AAA</txt> <txt/> <txt/> <txt>BBB</txt>. In Gekko 1.5.7 the colspan logic works like it does regarding HTML tables, everything else would be too confusing. This change may break prior tables, and the remedy is to delete such "placeholder" elements (typically <txt> tags).
• There was a bug related to convergence check of damped variables in the Gauss algorithm. Convergence checks were done on damped values, whereas it is really more meaningful to do it on non-damped values. The bug mostly shows up with hard damping (damp < 0.3) and in small models. Perhaps the ideal fix for this problem is to do a full non-damped iteration, and check that this iteration does not change too much.
  

• Fixed a bug that meant that an expression like "@variable(-1)" could not be parsed.
  
• Else, the work regarding 1.5.6 is mostly regarding unit testing. That is, a lot of tests that automatically check different functionality before the code is released.

• Introduced command TRIMVARS. This command removes all non-model variables from the Work and Base databanks. The command is handy if the databank contains a lot of superflous or irrelevant variables that are not part of the model.
• Opened up the possibility of running tables written in C#. This will not be supported in the long run, but until then, the C# tables can be called with the TABLEOLD instead of TABLE.

• Banknames are shown with smarter truncation in the user interface, and tooltip on status bar is introduced.
• When a command fails, you may click a link that provides more technical information regarding the error. I.e., the type of error, and where the error occured in the C# source code. You may copy-paste this information and send to the Gekko editor for review and possible fixing.
• Error report can be produced/packed when simulation fails. You may click a link and have Gekko pack a zip file containing model, databank and options to reproduce the problem. The zip file may be sent to the Gekko editor for review and possible fixing. This makes it much easier to cut out a problematic simulation from a system of command files. Also, when simulation fails, you now always get a link that when clicked reverts all variables to their pre-simulation values (before this had to be done via an option and command UNDOSIM, so this is now much easier).
  
• DISP can now search variable labels: for instance DISP 'import'. Note that the search text must be in single quotes (').
  
• Option solve fast yes|no. Default: yes. Switches to faster implementation of solvers. The speedup has mostly to do with the way data is read from in-RAM databanks. The trick is to create an intermediate twodimensional array (variables x periods) to use while simulating, and reading in and out of this array. This mode may still be buggy, but has been tested quite a lot. But please still use with care.
• Option solve data init growth yes|no. Default: yes. Uses more intelligent starting values for Gauss, looking at historical growth rates (only works with 'fast' option).
• Option solve data init growth min/max = value. See above. Default: -0.02 and 0.06, which seems best. The options makes Gekko look at historical growth rates when setting starting values. Reduces the number of iterations in many cases, especially models with stable long-term growth.
  
• Option solve newton invert = lu|iter. Default: lu. This is a faster and more precise way to invert the Jacobi matrix in the Newton algorithm. But it is also more strict, so it may protest where the other one does not (for instance if the model contains an equation like X = X, which means that the value of X is completely undetermined).
  
• Option solve newton invert fast yes|no. Default: yes. This is better in all cases, and the option will soon disappear.
• Option solve print iter yes|no.  Default: no, so iterations are not printed anymore. (However, there is always a link to click for seeing the iterations).
• Option patch zvar. Default: no. Will be set to 'yes' in version 1.6. It has to do with equations with for instance _D__D of _G__D codes. These equations have D- and Z-variables, but no J-variables. Unless 'yes' is set, the Z-variable did not follow the left-hand side variable after simulation, but this is corrected now. Mostly relevant when doing experiments/multipliers, not scenarios.
  
• Caching of models in memory. When ENDO/EXO variables were set (or removed), the older Gekko versions had to recompile (part of) the model. This information is now kept in memory, so if you are using the same ENDO/EXO variables on the same model (in the same session), Gekko will respond much more quickly (and run the simulations faster). This may consume memory, so if memory becomes problematic, you may use OPTION model cache mem max = 0 (or some low number). Default is 20, corresponding to 20 cached models.
  
• Fixed large memory consumption problem while reading tsd files. A RAM area of 100 MB was used. This has been changed, so that only an area corresponding to the databank file size is used. Also, memory errors will be better reported in 1.5.4.
• Fixed two bugs related to timeseries objects. The timeseries use arrays to contain data, and with many observations (>200), these arrays resize. This scheme contained some bugs that have not been exposed until now. The bugs just make Gekko stop (for instance while writing a databank), but they are still annoying.
• Target icon: when EXO/ENDO goals/means are set, an icon indicates this (including the number of goals). The icon is next to the red/yellow/green traffic lights in the status bar.
  
• Can use WRITE<caps> in addition to WRITE<caps=yes>. This is necessary for AREMOS to be able to read the tsd file.
  
• OPTION interface csv decimalseparator = period|comma. Default: period. Can set comma/period for WRITE<csv>.
• OPTION solve gauss goal switchback = yes|no can be used. Default: no. If set to yes, a goal search (via. EXO/ENDO command) started from the gauss algorithm will revert to gauss when finished (with no goals set). This is actually the way PCIM behaves regarding goals/means.
• Command GAUSS sets gauss method (and clears any EXO/ENDO goals)
• Command CLEARGOALS clears any EXO/ENDO goals.
• You can now set a pipe folder, for piping files (PIPE). Use OPTION folder pipe = [folder]. As usual, you can use relative paths (relative to working folder), for instance "OPTION folder pipe = \output".
• Second level of the OPTION hierarchy can be shown. For instance, instead of "OPTION ?", try "OPTION folder ?".

• option calc ignoremissingvars = no. In 1.4 an UPD statement with a missing variable would just issue a warning and be skipped. In 1.5.4 Gekko stops (if this option is 'no').
• option folder pipe = [empty]. See above.
  
• option folder working = [empty]. Sets working folder.
• option interface csv decimalseparator = period. See above.
• option interface excel decimalseparator = period. Can be set to 'comma' for Danish Excel. The setting is actually only used for CPLOT, since WPLOT copies data via so-called interop.
• option interface excel language = danish. Actually only used for CPLOT -- will write "ikke.tilgængelig()" for cells with missing values.
• option model cache mem max = 20. See above.
• option patch zvar = no. See above.
• option print disp maxlines = 3. How many data lines are shown in DISP.
• option solve data init growth = yes.  See above.
• option solve data init growth min = -0.02.  See above.
• option solve data init growth max = 0.06.  See above.
• option solve fast = yes.  See above.
• option solve gauss goal switchback = no. See above.
• option solve newton invert = lu.  See above.
• option solve newton invert fast = yes. See above.
• option solve print details = no. If 'yes', a lot of details will be printed in the Newton algorithm.
• option solve print iter = no.  See above.
• option table ignoremissingvars = yes. If yes, cells with missing variables are shown with 'N', indicating a missing variable ('M' means missing data in existing variable).
• option table startfile = menu.html. Startfile regarding menu files. 

• option solve newton feedback = yes. This is always much faster, so no need to be able to disable feedback methodology for Newton solving.