solver_nc_analyzer.m

function [Q,U,R,T,C,X,lG,runtime,iter,method] = solver_nc_analyzer(sn, options)
% [Q,U,R,T,C,X,LG,RUNTIME,METHOD] = SOLVER_NC_ANALYZER(QN, OPTIONS)
 
% Copyright (c) 2012-2026, Imperial College London
% All rights reserved.
Tstart = tic;
 
line_debug('NC analyzer starting: method=%s, nstations=%d, nclasses=%d, njobs=%s', options.method, sn.nstations, sn.nclasses, mat2str(sn.njobs));
 
% Order-independent (OI) closed network: explicit request, or auto-detected
% when the closed model consists solely of OI and delay stations. Solved
% exactly by the balanced-fairness normalizing constant (pfqn_oi_nc) with the
% OI functional-server (pfqn_oi_fnc) identity for the mean queue lengths.
if nc_is_oi_model(sn) && any(strcmpi(options.method, {'default','exact'}))
    line_debug('NC analyzer routing to solver_nc_oi_analyzer (order-independent)');
    [Q,U,R,T,C,X,lG,runtime,iter,method] = solver_nc_oi_analyzer(sn, options);
    return
end
 
% Importance sampling ('is') specialized to OI / pass-and-swap (P&S) stations:
% the auto-normalized IS normalizing constant pfqn_pas_is (which reduces to
% pfqn_oi_is when the swap graph is empty). Triggers on the explicit IS selector
% 'is'; on 'sampling', which maps to 'is' in the presence of OI/PAS stations
% (rather than the generic pfqn_mci/pfqn_ls estimators); and on 'default' for a
% P&S tandem with a non-empty swap graph, which is reducible and has no exact
% path (a pure-OI tandem on 'default'/'exact' is caught by the exact OI analyzer
% above).
if nc_is_pas_model(sn) && any(strcmpi(options.method, {'default','is','sampling'}))
    line_debug('NC analyzer routing to solver_nc_pas_is_analyzer (pass-and-swap IS)');
    [Q,U,R,T,C,X,lG,runtime,iter,method] = solver_nc_pas_is_analyzer(sn, options);
    return
end
 
% 'is' is the sample-an-ordering importance-sampling family. OI / pass-and-swap
% stations are handled above (pfqn_pas_is / pfqn_oi_is); every other CLOSED
% product-form network falls through to the standard normalizing-constant path,
% where pfqn_nc routes 'is' to pfqn_is (load-independent) and pfqn_ncld routes it
% to pfqn_ld_is (load-dependent). The estimator has no open-class form.
if strcmpi(options.method, 'is') && any(isinf(sn.njobs))
    line_error(mfilename, 'The ''is'' importance-sampling method requires a closed queueing network. Use ''sampling'' (pfqn_mci/pfqn_ls) for open or mixed models.');
end
 
% Maximum Entropy Method (Kouvatsos 1994): explicit request only. The
% method='default' path routes to the native normalizing-constant analyzer
% (solver_nc), as it did before MEM was introduced.
if strcmpi(options.method, 'mem')
    line_debug('NC analyzer routing to solver_nc_mem (Maximum Entropy)');
    [Q,U,R,T,C,X,iter] = solver_nc_mem(sn, options);
    lG = NaN;
    method = 'mem';
    runtime = toc(Tstart);
    return
end
 
nservers = sn.nservers;
if max(nservers(nservers<Inf))>1 & any(isinf(sn.njobs)) & strcmpi(options.method,'exact') %#ok<AND2>
    line_error(mfilename,'NC solver cannot provide exact solutions for open or mixed queueing networks. Remove the ''exact'' option.');
end
 
% interpolate for non-integer closed populations
eta = abs(sn.njobs - floor(sn.njobs));
if any(eta>GlobalConstants.FineTol)
    line_debug('Fractional populations detected, using interpolation');
    sn_floor = sn; sn_floor.njobs = floor(sn.njobs);
    [Qf,Uf,Rf,Tf,Cf,Xf,lGf,~,iterf] = solver_nc(sn_floor, options);
    sn_ceil = sn; sn_ceil.njobs = ceil(sn.njobs);
    [Qc,Uc,Rc,Tc,Cc,Xc,lGc,~,iterc,method] = solver_nc(sn_ceil, options);
    Q = Qf +  eta .* (Qc-Qf);
    U = Uf +  eta .* (Uc-Uf);
    R = Rf +  eta .* (Rc-Rf);
    T = Tf +  eta .* (Tc-Tf);
    C = Cf +  eta .* (Cc-Cf);
    X = Xf +  eta .* (Xc-Xf);
    lG = lGf +  eta .* (lGf-lGc);
    iter = iterc + iterf;
    line_debug('NC interpolation complete: used %d + %d iterations', iterf, iterc);
else % if integers or open model
    if any(isinf(sn.njobs))
        line_debug('Open/mixed model detected, calling solver_nc');
    else
        line_debug('Using exact integer populations, calling solver_nc');
    end
    [Q,U,R,T,C,X,lG,~,iter,method] = solver_nc(sn, options);
end
runtime = toc(Tstart);
end