Appendix > Balancing (RAS/GRAS)

TODO: On this page, the balance() function will be fully documented. Until then, you can try the following. The types 'ras' and 'gras' are most stable and have been tested the most at the moment.

reset;
time 2020 2020;
io = series(2);
io[a,a] = 10;
io[a,b] = 20;
io[a,c] = 30;
io[a,d] = 7;
io[b,a] = 50;
io[b,b] = 60;
io[b,c] = 70;
io[b,d] = 17;
io[c,a] = 90;
io[c,b] = 80;
io[c,c] = 70;
io[c,d] = 27;
rowsum = series(1);
rowsum[a]= 87;
rowsum[b]= 147;
rowsum[c]= 287;
colsum = series(1);
colsum[a]= 160;
colsum[b]= 170;
colsum[c]= 140;
colsum[d]= 51;
#rownames = a, b, c;
#colnames = a, b, c, d;
prt <n> io;

#constraints1 = ((('a','a',-1), ('a','b',1), 0 ), (('b','d',2) ,('c','d',2), 120 ));
#constraints2 = ((('a','a'), 10),);
#exo = (('a','a'),);

io0a_ras = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'ras'));
prt <n> io0a_ras;

io0a_entropy = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'entropy'));
prt <n> io0a_entropy;

io0a_entropy2003 = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'entropy2003'));
prt <n> io0a_entropy2003;

io0a_gras = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'gras'));
prt <n> io0a_gras;

io0a_sqdif = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'sqdif'));
prt <n> io0a_sqdif;

io0a_sqrel = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'sqrel'));
prt <n> io0a_sqrel;

io0a_distdif = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'distdif'));
prt <n> io0a_distdif;

io0a_distrel = balance(io, rowsum, colsum, #rownames, #colnames, (%type = 'distrel'));
prt <n> io0a_distrel;

// -----

io0b_entropy = balance(io, rowsum, colsum, #rownames, #colnames, (#constraints = #constraints1, %type = 'entropy'));
prt <n> io0b_entropy;

// -----

io0c_entropy = balance(io, rowsum, colsum, #rownames, #colnames, (#exo = #exo, %type = 'entropy')); //#exo does not work?
prt <n> io0c_entropy;

io0c_ras = balance(io, rowsum, colsum, #rownames, #colnames, (#exo = #exo, %type = 'ras'));
prt <n> io0c_ras;

io0c_gras = balance(io, rowsum, colsum, #rownames, #colnames, (#exo = #exo, %type = 'gras'));
prt <n> io0c_ras;

// -----

io0d_entropy = balance(io, rowsum, colsum, #rownames, #colnames, (#constraints = #constraints2, %type = 'entropy'));
prt <n> io0d_entropy;

When using #exo, #constraints and #weights, remember than in Gekko a list with 1 element is written as for instance ('x',), not ('x'). In the latter case Gekko just removes the parentheses and reads it as 'x'. (The same logic is known from Python tuples).

Types

In the following, x[i, j] is the resulting cell, and a[i, j] is the original/initial cell.

•%type = 'ras'. Normal RAS procedure where first the rows are adjusted to match the sums, then the columns, then the rows, etc. An optimization solver is not used.

•%type = 'gras'. GRAS is the "generalized" RAS procedure, where first the rows are adjusted to match the sums, then the columns, then the rows, etc. The difference relative to the RAS procedure is that positive and negative cells for a row or column move in the same direction. An optimization solver is not used. If all the input cells are >= 0, GRAS returns the same cells as RAS.

•%type = 'entropy'. For each cell, the measure abs(a[i, j]) * (x[i, j] / a[i, j] * log(x[i, j] / a[i, j]) - x[i, j] / a[i, j] + 1) is used. With only #exo constraints, and when this solves, the result is the same as %type = 'gras'. Refer to 2013 article.

•%type = 'entropy2003'. For each cell, the measure x[i, j] * log(x[i, j] / a[i, j]) is used. Refer to 2003 article.

•%type = 'sqdif'. For each cell, the measure (x[i, j] - a[i, j])**2 is used.

•%type = 'sqrel'. For each cell, the measure ((x[i, j] - a[i, j])/a[i, j])**2 is used.

•%type = 'distdif'. For each cell, the measure abs(x[i, j] - a[i, j]) is used.

•%type = 'distrel'. For each cell, the measure abs((x[i, j] - a[i, j])/a[i, j]) is used.

'entropy' should be better than 'entropy2003' for some corner cases, but mostly yield identical results.

Tolerance

In addition to %type = ... , #exo = ..., #constraints = ... and #weights = ... , you may also change the tolerance with %tol = ... . The default value is 0.0001, and is set as an absolute value. The smaller the tolerance, the more precision regarding the cells (including how well the output cell row and column totals match the input rowsum and colsum).

Exogenized cells

Exogenization (#exo = ...) works for all types, and the input is simply a list of cell coordinates.

Constraints and weights

Constraints (#constraints = ...) will bind for each type. Constraints are not allowed for 'ras' or 'gras' (unless exogenizing single cells: use an #exo list).

Weights (#weights = ...) are multiplied onto each cell, the default weight being value 1. So a weight > 1 will make the cell move less relative to its original value. Weights are not possible for 'ras' or 'gras'.

Iterations min/max

You may set %itermin = ... and %itermax = ... . With these, you can limit the iterations. Since RAS/GRAS are fast, and the convergence checks need more work, setting an %itermin = 1000 may not be a bad idea to make sure the cell tolerances are met.