TimeSelector.m

Go to the documentation of this file.

namespace data{
namespace selection{


/* (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 TimeSelector
  :public data.selection.ASelector {
    public: /* ( setObservable ) */

        Size = 10000;
        Seed = 1;
    public: /* ( setObservable ) */

        TimeSelector() {
            this = this@data.selection.ASelector;
            this.registerProps(" Size "," Seed ");
        }


        function copy = clone() {
            copy = data.selection.TimeSelector;
            /* copy = clone@data.selection.ASelector(this, copy); */
            copy.Size= this.Size;
            copy.Seed= this.Seed;
        }

    
    protected: /* ( Sealed ) */ /* ( setObservable ) */

        function [matrixxi , rowvecti , matrixmui , fxi ] = select(models.BaseFullModel model) {

            /*  Build sn array similar to old one */
            d = model.Data.TrajectoryData;
            nt = d.getNumTrajectories;
            times = model.Times;
            tlen = length(times);

            if nt*tlen > this.Size
                /*  So many samples for each timestep (fill rest with random samples) */
                num = floor(this.Size/tlen);
                s = RandStream.create(" mt19937ar "," Seed ",this.Seed);
                /*  These are the time step indices that have to be selected overall */
                selidx = repmat(s.randperm(tlen),1,num);
                /*  How many per trajectory?
                 * MUST be smaller than tlen, as otherwise selecting more timesteps per
                 * trajectory than available would have meant that nt*tlen < this.Size.
                 * This means also that repeating the random permutation of 1:tlen will not lead
                 * to double selection of a time within the same trajectory. */
                protraj = floor(length(selidx)/nt); 

                sel = logical.empty;
                for tn = 1:nt
                    /*  Select nothing by default */
                    hlp = false(1,tlen);
                    /*  select "protraj" many sequentially */
                    step = (1:protraj)+(tn-1)*protraj;
                    /*  set those to true */
                    hlp(selidx(step)) = true;
                    /*  Store in selection array at range for current trajectory */
                    sel = [sel hlp]; /* #ok<*AGROW> */

                end

                /*  Add up to full this.Size selection */
                left = this.Size - protraj * nt;
                notsel = find(~sel);
                selsel = s.randperm(length(notsel),left);
                sel(notsel(selsel)) = true;
            else
                sel = true(1,nt*tlen); /*  Select everything! */

            end

            xi = []; ti = []; mui = [];
            for tn = 1:nt
                [x, mu] = d.getTrajectoryNr(tn);
                idx = (1:tlen) + (tn-1)*tlen;
                xi = [xi x(:,sel(idx))];
                newt = times(sel(idx));
                ti = [ti newt];
                if ~isempty(mu)
                    mui = [mui mu(:,ones(1,length(newt)))];
                end
            end
            fxi = [];
        }
    public: /* ( setObservable ) */

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

#endif


        
#if 0 //mtoc++: 'set.Seed'
function  Seed(value) {
            if ~isreal(value)
                error(" The value must be a real value. ");
            end
            this.Seed= value;
        }

#endif

};
}
}