RandomSampler.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 RandomSampler
  :public sampling.BaseSampler {
    public: /* ( setObservable ) */

        Samples = 30;
        integer Seed = "[]";
    public: /* ( setObservable ) */


        RandomSampler() {
            this.registerProps(" Samples ");
        }


        
#if 0 //mtoc++: 'set.Samples'
function  Samples(value) {
            if ~isposintscalar(value)
                error(" Value must be a positive integer scalar ");
            end
            this.Samples= value;
        }

#endif


        function matrix<double>samples = performSampling(params) {
            if isempty(this.Seed)
                seed = round(cputime*100);
            else
                seed = this.Seed;
            end
            r = RandStream(" mt19937ar "," Seed ",seed);

            nparams = length(params);

            if isempty(this.Domain)
                factor = r.rand(nparams,this.Samples);
                miv = repmat([params(:).MinVal]^t,1,this.Samples);
                mav = repmat([params(:).MaxVal]^t,1,this.Samples);
                islog = strcmp([params(:).Spacing]," log ")^t;
                if any(islog)
                    miv(islog,:) = log10(miv(islog,:));
                    mav(islog,:) = log10(mav(islog,:));
                end
                samples = miv + factor.*(mav-miv);
                if any(islog)
                    samples(islog,:) = 10.^samples(islog,:);
                end
                /*  Create samples according to the given Domain */
            else
                if size(this.Domain.Points,1) ~= nparams
                    erros(" Dimension of Domain does not match the parameter count. ");
                end
                samples = zeros(nparams,this.Samples);
                pos = 1;
                while pos < this.Samples
                    /*  create new samples */
                    factor = r.rand(nparams,this.Samples);
                    miv = repmat([params(:).MinVal]^t,1,this.Samples);
                    mav = repmat([params(:).MaxVal]^t,1,this.Samples);
                    islog = strcmp([params(:).Spacing]," log ")^t;
                    if any(islog)
                        miv(islog,:) = log10(miv(islog,:));
                        mav(islog,:) = log10(mav(islog,:));
                    end
                    newsamples = miv + factor.*(mav-miv);
                    if any(islog)
                        newsamples(islog,:) = 10.^newsamples(islog,:);
                    end

                    /*  Filter the new samples by the domain and augment */
                    newsamples = this.Domain.filter(newsamples);
                    numnew = size(newsamples,2);
                    spos = pos:min(pos+numnew-1, this.Samples);
                    npos = 1:min(numnew,this.Samples-pos+1);
                    samples(:,spos) = newsamples(:,npos);
                    pos = spos(end) + 1;
                end
            end
            /*  Sort samples if one-dimensional */
            if size(samples,1) == 1
                samples = sort(samples);
            end
        }
    public: /* ( Static ) */ /* ( setObservable ) */


        static function res = test_DomainSampling() {
            m = models.BaseFullModel;
            s = models.BaseFirstOrderSystem(m);
            m.System=s;
            s.addParam(" param_a ", 1);
            s.addParam(" param_b ", 34);
            /* points = rand(2,200); */
            points = [0.69*sin(0:0.05:pi/2); 0.69*cos(0:0.05:pi/2)];
            points = [points [0.7*sin(0:0.05:pi/2); 0.7*cos(0:0.05:pi/2)]];
            valid = Norm.L2(points) >= .7;
            m.Sampler= sampling.RandomSampler;
            d = sampling.Domain(points, valid);
            m.Sampler.Domain= d;
            m.Sampler.Samples= 500;
            samples = m.Sampler.generateSamples(m);
            res = all(Norm.L2(samples) > .66);
            plot(samples(1,:),samples(2,:)," o ",...
                d.Points(1,:),d.Points(2,:)," * ",...
                0.7*sin(0:0.05:pi/2),0.7*cos(0:0.05:pi/2))
        }
    protected: /* ( Static ) */ /* ( setObservable ) */

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

    
};
}