RBFConfig.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 RBFConfig
  :public IClassConfig {
    public:

        Gammas;

        
    public:

        RBFConfig(varargin) {
            
            i.KeepUnmatched= true;
            i.addParamValue('G',[]);
            i.parse(varargin[:]);
            r = i.Results;
            if isempty(r.G)
                this.Gammas= 1;
            else
                this.Gammas= r.G;
            end
            this.RequiredPrototypeClass= " kernels.ARBFKernel ";
        }


        function n = getNumConfigurations() {
            n = length(this.Gammas);
        }


        function k = configureInstance(nr) {
            k = this.getProtoClass;
            k.Gamma= this.Gammas(nr);
        }


        function str = getConfigurationString(nr,asCell) {
            if nargin < 3
                asCell = false;
            end
            if asCell
                str = [];
                if ~isempty(this.Gammas)
                    str[1] = sprintf(" %g ",this.Gammas(nr));
                end
            else
                str = [];
                if ~isempty(this.Gammas)
                    str = sprintf(" \\gamma: %g ",this.Gammas(nr));
                end
            end
        }


        function str = getConfiguredPropertiesString() {
            str = " \gamma ";
        }


        function conf = getSubPart(partNr,totalParts) {
            conf = this.clone;
            conf.Gammas= this.Gammas(this.getPartIndices(partNr, totalParts));
        }


        function copy = clone(copy) {
            if nargin < 2
                copy = kernels.config.RBFConfig;
            end
            copy = clone@IClassConfig(this, copy);
            copy.Gammas= this.Gammas;
        }

    
    protected:

        function  collectRanges(ptable,proppath) {
            this.addRange(ptable, [proppath [" gamma "]],min(this.Gammas),max(this.Gammas));
        }

    
    public: /* ( Static ) */

        static function dists = getDists(data.ApproxTrainData atd,integer num) {

            dfun = @logsp; /*  distances comp fun (linsp / logsp) */


            Mf = 2;
            mf = .5;
            if isscalar(mf)
                mf = ones(3,1)*mf;
            end
            if isscalar(Mf)
                Mf = ones(3,1)*Mf;
            end
            xm = atd.xiDia;
            dists = dfun(mf(1)*xm, Mf(1)*atd.xiDia);
            if atd.hasTime
                tm = atd.tiDia;
                dists(2,:) = dfun(mf(2)*tm, Mf(2)*atd.tiDia);
            end
            if atd.hasParams
                mum = atd.muiDia;
                dists(3,:) = dfun(mf(3)*mum, Mf(3)*atd.muiDia);
            end

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

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

            function d = logsp(from, to)
                d = logspace(log10(from),log10(to),num);
            end
        }
};
}
}