ExpansionConfig.m

Go to the documentation of this file.

namespace kernels{
namespace config{


/* (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 ExpansionConfig
  :public IClassConfig {
    public:

        IClassConfig StateConfig = "[]";
    public:

        ExpansionConfig() {
            this.RequiredPrototypeClass= " kernels.KernelExpansion ";
            this.Prototype= kernels.KernelExpansion;
        }


        function n = getNumConfigurations() {
            n = 0;
            if ~isempty(this.StateConfig)
                n = this.StateConfig.getNumConfigurations;
            end
        }


        function kernels.KernelExpansionkexp = configureInstance(nr) {
            kexp = this.getProtoClass;
            if ~isempty(this.StateConfig)
                kexp.Kernel= this.StateConfig.configureInstance(nr);
            end
        }


        function str = getConfigurationString(nr,asCell) {
            if nargin < 3
                asCell = false;
            end
            str = [];
            if ~isempty(this.StateConfig)
                str = sprintf(" StateKernel: %s ",...
                    this.StateConfig.getConfigurationString(nr, asCell));
            end
        }


        function str = getConfiguredPropertiesString() {
            str = this.StateConfig.getConfiguredPropertiesString;
        }


        function conf = getSubPart(partNr,totalParts) {
            conf = this.clone;
            if ~isempty(this.StateConfig)
                conf.StateConfig= this.StateConfig.getSubPart(partNr, totalParts);
            end
        }


        function copy = clone(copy) {
            if nargin < 2
                copy = kernels.config.ExpansionConfig;
            end
            copy = clone@IClassConfig(this, copy);
            if ~isempty(this.StateConfig)
                copy.StateConfig= this.StateConfig.clone;
            end
        }


        function  guessGammaConfigs(data.ApproxTrainData atd,integer ng,double mf,double Mf) {

            if ~isa(atd," data.ApproxTrainData ")
                error(" First argument has to be a data.ApproxTrainData instance ");
            end
            gameps = .1;
            if nargin < 5
                Mf = 2;
                if nargin < 4
                    mf = .5;
                end
            end
            dfun = @logsp;

            dists = zeros(3,ng);
            dists(1,:) = dfun(mf*atd.xiDia, Mf*atd.xiDia);
            if atd.hasTime
                dists(2,:) = dfun(mf*atd.tiDia, Mf*atd.tiDia);
            end
            if atd.hasParams
                dists(3,:) = dfun(mf*atd.muiDia, Mf*atd.muiDia);
            end
            k = kernels.GaussKernel;
            this.Gammas= zeros(size(dists));
            for i=1:ng
               this.Gammas(1,i) = k.setGammaForDistance(dists(1,i),gameps);
               this.Gammas(2,i) = k.setGammaForDistance(dists(2,i),gameps);
               this.Gammas(3,i) = k.setGammaForDistance(dists(3,i),gameps);
            end

            function linsp(from, to)/* #ok */

                d = linspace(from,to,ng);
            end

            function d = logsp(from, to)
                d = logspace(log10(from),log10(to),ng);
            end
        }
    protected:

        function  collectRanges(ptable,proppath) {
            if ~isempty(this.StateConfig)
                this.StateConfig.collectRanges(ptable, ...
                    [proppath [sprintf(" State(%s) ",this.StateConfig.getClassName)]]);
            end
        }


        function obj = loadobj() {
            if ~isa(obj, " kernels.config.ExpansionConfig ")
                from = obj;
                obj = kernels.config.ExpansionConfig;
                obj = loadobj@IClassConfig(obj, from);
                obj.StateConfig= from.StateConfig;
            end
        }

    

};
}
}