k out of n with smallest bandwidth

$ontext

   Given a data vector v(i) of legth n, find k elements (k<n)
   that are closest to each other.

$offtext


*-------------------------------------------------------
* problem size
*-------------------------------------------------------

set i 'length of data vector'/i1*i1000/;

scalar k 'number of selected items'/100/;

*-------------------------------------------------------
* random data
*-------------------------------------------------------

parameter v(i) 'random data';
v(i) = uniform(-100,100);
display v,k;

*-------------------------------------------------------
* derived data
*-------------------------------------------------------

scalars
   vmin
   vmax
   M 'big-M'
;
vmin = smin(i,v(i));
vmax = smax(i,v(i));
M = vmax-vmin;


*-------------------------------------------------------
* reporting macros
*-------------------------------------------------------

acronym TimeLimit;
acronym Optimal;
acronym Error;

parameter results(*,*);
$macro report(m,label)  \
    results('points',label) = card(i); \
    results('vars',label) = m.numVar; \
    results('  discr',label) = m.numDVar; \
    results('equs',label) = m.numEqu; \
    results('status',label) = Error; \
    results('status',label)$(m.solvestat=1) = Optimal; \
    results('status',label)$(m.solvestat=3) = TimeLimit; \
    results('obj',label) = m.objval; \
    results('time',label) = m.resusd; \
    results('nodes',label) = m.nodusd; \
    results('iterations',label) = m.iterusd; \
    results('gap%',label)$(m.solvestat=3) = 100*abs(m.objest - m.objval)/abs(m.objest); \
    display results;

*-------------------------------------------------------
* MIP Model
*
* Note: R will be substituted out. So the solver
* will see U-L as objective function.
*-------------------------------------------------------


variables
   L     'lower bound on selected values'
   U     'upper bound on selected values'
   R     'U-L'
;

U.lo = vmin; U.up = vmax;
L.lo = vmin; L.up = vmax;

binaryvariables delta(i) 'selection of data points';

equations
    obj          'objective'
    vminbound(i) 'delta(i)=1 ==> v(i)>=L'
    vmaxbound(i) 'delta(i)=1 ==> v(i)<=U'
    select       'k to be selected'
;

obj.. R =e= U-L;

vmaxbound(i).. v(i) =l= U + (1-delta(i))*M;
vminbound(i).. v(i) =g= L - (1-delta(i))*M;

select.. sum(i, delta(i)) =e= k;

model m1 /all/;
options threads=0;
solve m1 minimizing R using mip;

display delta.l,U.l,L.l,R.l;
report(m1,"MIP")

*-------------------------------------------------------
* Add bound R>=0
*
* R will no longer be substituted out.
*-------------------------------------------------------

* the next one is important for performance
R.lo = 0;

solve m1 minimizing R using mip;
report(m1,"IMPROVED")

*-------------------------------------------------------
* Algorithm
*-------------------------------------------------------

* in case we have zeros
v(i) = EPS+v(i);

set psol(i) 'Python solution';

scalar time;
time = timeElapsed;

embeddedCode Python:

#
# get GAMS data
#
k = int(list(gams.get("k"))[0])
v = list(gams.get("v"))

#
# sort v
#
v.sort(key = lambda x: x[1])

#
# find best range
#
n = len(v)
bestr = 1.0e10
bestj = 1e10
for j in range(0,n-k+1):
    r = v[j+k-1][1]-v[j][1]
    if r < bestr:
       bestr = r
       bestj = j
print(f"Best range:{bestr} at j={bestj}")

#
# report solution back as subset
#
sol = []
for j in range(bestj,bestj+k):
    sol.append(v[j][0])
gams.set("psol",sol)

endEmbeddedCode psol

time = timeElapsed-time;


display psol;
results('obj','SORTING') = smax(psol,v[psol])-smin(psol,v[psol]);
results('time','SORTING') = time;
results('points','SORTING') = card(i);
display results;