GridSampler.m

Go to the documentation of this file.

namespace sampling{


/* (Autoinserted by mtoc++)
 * This source code has been filtered by the mtoc++ executable,
 * which generates code that can be processed by the doxygen documentation tool.
 *
 * On the other hand, it can neither be interpreted by MATLAB, nor can it be compiled with a C++ compiler.
 * Except for the comments, the function bodies of your M-file functions are untouched.
 * Consequently, the FILTER_SOURCE_FILES doxygen switch (default in our Doxyfile.template) will produce
 * attached source files that are highly readable by humans.
 *
 * Additionally, links in the doxygen generated documentation to the source code of functions and class members refer to
 * the correct locations in the source code browser.
 * However, the line numbers most likely do not correspond to the line numbers in the original MATLAB source files.
 */

class GridSampler
  :public sampling.BaseSampler {
    public:


        function samples = performSampling(params) {

            nparams = length(params);
            ranges = cell(nparams,1);

            /*  Create linearly spaced parameter value ranges */
            for pidx=1:nparams
                /*  Cater for single parameters  */
                if (params(pidx).MinVal == params(pidx).MaxVal)
                    ranges[pidx] = params(pidx).MinVal;
                else
                    if strcmp(params(pidx).Spacing," lin ")
                        ranges[pidx] = linspace(params(pidx).MinVal,...
                        params(pidx).MaxVal,...
                        params(pidx).Desired);
                    elseif strcmp(params(pidx).Spacing," log ")
                        /*  TODO? modify if statements 
                         * TODO? uneven params(pidx).Desired) */
                        if params(pidx).MinVal == 0
                            /*  then, NaNs due to log10(0) have to be avoided, further MaxVal \neq 0 */
                            m = -16;    /*  take double precision zero */

                            M = log10(params(pidx).MaxVal);
                            ranges[pidx] = logspace(m, M, params(pidx).Desired);
                        elseif params(pidx).MaxVal == 0
                            /*  then, NaNs due to log10(0) have to be avoided, further MinVal \neq 0 */
                            m = log10(params(pidx).MinVal);
                            M = -16;    /*  take double precision zero */

                            ranges[pidx] = logspace(m, M, params(pidx).Desired);
                        elseif params(pidx).MinVal < 0
                            /*  need to split the interval into -[10^ml,10^Ml] [10^mr,10^Mr], 
                             * as no logarithm of negative number exists */
                            ml = log10(abs(params(pidx).MinVal));
                            Mr = log10(params(pidx).MaxVal);
                            if ml == Mr
                                divl = params(pidx).Desired/2;
                                divr = params(pidx).Desired/2;
                                Ml = ml - divl + 1;
                                mr = Mr - divr + 1;
                            elseif ml < Mr
                                diff = Mr - ml;
                                divl = (params(pidx).Desired - diff)/2;
                                divr = divl + diff;
                                Ml = ml - divl + 1;
                                mr = Mr - divr +1;
                            elseif ml > Mr
                                diff = ml - Mr;
                                divr = (params(pidx).Desired - diff)/2;
                                divl = divr + diff;
                                Ml = ml - divl + 1;
                                mr = Mr - divr +1;
                            end
                            ranges[pidx] = [-logspace(ml, Ml, divl) logspace(mr, Mr, divr)];
                        else
                            m = log10(params(pidx).MinVal);
                            M = log10(params(pidx).MaxVal);
                            ranges[pidx] = logspace(m, M, params(pidx).Desired);
                        end
                    end
                end
            end

            /*  Return first range if only one available. */
            if nparams == 1
                samples = ranges[1];
            else
                samples = Utils.createCombinations(ranges);
            end

            /*  Restrict samples to given domain if set */
            if ~isempty(this.Domain)
                samples = this.Domain.filter(samples);
            end
        }
    protected: /* ( Static ) */

        static function obj = loadobj(obj) {
            if ~isa(obj," sampling.GridSampler ")
                obj = sampling.GridSampler;
            end
            obj = loadobj@sampling.BaseSampler(obj);
        }
};
}