Uniform.m

classdef Uniform < ParameterSampling.IRefineable
  % Parameter sampling class with uniformly distributed parameters in the
  % parameter space.

  properties (SetAccess = private, Dependent)
    % @copybrief ParameterSampling.Interface.sample
    sample;
  end

  properties
    % boolean value determining whether a logarithmic function shall be
    % applied on the uniform distribution of the parameter samples.
    log_distribution  = false;

    % vector or scalar determining how many equally distant vectors shall be
    % added to the parameter sample in each direction.
    %
    % If it is a vector, for each direction of the parameter space a different
    % number can be given.
    init_numintervals = 2;
  end

  properties (Access = public)
    % underlying grid of type cubegrid
    pgrid;
  end

  methods
    function ups = Uniform(init_numintervals, log_distribution)
      % function ups = Uniform(init_numintervals, log_distribution)
      % constructor
      %
      % Parameters:
      %   init_numintervals: vector or scalar determining how many equally
      %                      distant vectors shall be added to the parameter
      %                      sample in each direction.
      %   log_distribution:  boolean indicator determining whether a
      %                      logarithmic function shall be applied on the
      %                      uniform distribution of the parameter samples.
      if nargin >= 1
        ups.init_numintervals = init_numintervals;
      end
      if nargin >= 2
        ups.log_distribution = log_distribution;
      end
    end

    function init_sample(this, dmodel)
      % function init_sample(this, dmodel)
      % @copybrief ParameterSampling.Interface.init_sample()
      %
      % @copydetails ParameterSampling.Interface.init_sample()

      if ~this.init_done
        if this.log_distribution
          params.range = cellfun(@log, dmodel.mu_ranges, 'UniformOutput', false);
        else
          params.range = dmodel.mu_ranges;
        end
        if isscalar(this.init_numintervals)
          params.numintervals = ones(1,length(params.range)) * this.init_numintervals;
        else
          params.numintervals = this.init_numintervals;
        end
        this.pgrid = cubegrid(params);
      end

      this.init_done = true;
    end

    function M = get.sample(this)
      if this.init_done
        M = get(this.pgrid, 'vertex');
        if this.log_distribution
          M = exp(M);
        end
      else
        M = [];
      end
    end

    function levels = get_refinement_levels(this)
      % function levels = get_refinement_levels(this)
      % @copybrief ParameterSamplingIRefineableget_refinement_levels()
      %
      % @copydetails ParameterSamplingIRefineableget_refinement_levels()
      levels = get(this.pgrid, 'level');
    end

    function size = size(this)
      % function size = size(this)
      % @copybrief ParameterSamplingInterfacesize()
      %
      % @copydetails ParameterSamplingInterfacesize()
      size = get(this.pgrid, 'nleafelements');
    end

    function this = refine(this, elems)
      % function this = refine(this, elems)
      % @copybrief ParameterSamplingIRefineablerefine()
      %
      % @copydetails ParameterSamplingIRefineablerefine()
      if nargin == 1
        elems = 1:length(this.pgrid.get_leafgids);
      end
      this.refined_elements = [this.refined_elements, {elems}];
      this.sample_history   = [this.sample_history,   this.sample];
      refine(this.pgrid, elems);
    end

    function cogs = cogs(this)
      % function cogs = cogs(this)
      % @copybrief ParameterSampling.IRefineable.cogs()
      %
      % @copydetails ParameterSampling.IRefineable.cogs()
      cogs = get(this.pgrid, 'leafcogs');
    end

    function skips = skipped_refinements(this)
      % function skips = skipped_refinements(this)
      % @copybrief ParameterSamplingIRefineableskipped_refinements()
      %
      % @copydetails ParameterSamplingIRefineableskipped_refinements()
      li = get_leafgids(this.pgrid);
      skips = this.pgrid.refine_steps - this.pgrid.creation_step(li);
    end

    function max_vertex = elementwise_maximum_of_vertex_values(this, values)
      % function max_vertex = elementwise_maximum_of_vertex_values(this, values)
      % @copybrief ParameterSamplingIRefineableelementwise_maximum_of_vertex_values()
      %
      % @copydetails ParameterSamplingIRefineableelementwise_maximum_of_vertex_values()
      li = get_leafgids(this.pgrid);
      lv = this.pgrid.vertexindex(li,:);

      value_vertex = reshape(values(lv(:)), size(lv));
      max_vertex   = max(value_vertex, [], 2);
    end
  end
end