AAdaptiveBase.m

Go to the documentation of this file.

namespace approx{
namespace algorithms{


/* (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 AAdaptiveBase
  :public approx.algorithms.ABase {
    public: /* ( setObservable ) */

        integer MaxExpansionSize = 300;
        double MaxRelErr = 1e-5;
        char InitialCenter = "maxfx";
    public:

        colvec<double> ExpansionSizes;
        Used = "[]";
    protected:

        initialidx;

        
    public:

        AAdaptiveBase() {
            this = this@approx.algorithms.ABase;

            /*  Register default property changed listeners */
            this.registerProps(" MaxExpansionSize "," MaxRelErr "," InitialCenter ");
        }


        function copy = clone(copy) {
            copy = clone@approx.algorithms.ABase(this, copy);

            /*  copy local props */
            copy.MaxExpansionSize= this.MaxExpansionSize;
            copy.MaxRelErr= this.MaxRelErr;
            copy.initialidx= this.initialidx;
            copy.InitialCenter= this.InitialCenter;
            copy.Used= this.Used;
        }
    protected: /* ( Sealed ) */

        function kernels.KernelExpansionkexp = templateComputeApproximation(data.ApproxTrainData atd,data.ApproxTrainData avd) {

            /* % Checks */
            if size(atd.xi,2) < this.MaxExpansionSize
                warning(" AAdaptiveBase:expansionsize ",...
                    " Only %d training samples but having MaxExpansionSize=%d, changing to %d. ",...
                    size(atd.xi,2),this.MaxExpansionSize,size(atd.xi,2));
                this.MaxExpansionSize= size(atd.xi,2);
            end

            /*  Init debug fields */
            nc = this.ExpConfig.getNumConfigurations;
            this.MaxErrors= zeros(nc,this.MaxExpansionSize);
            this.MaxRelErrors= this.MaxErrors;
            this.ValidationErrors= zeros(nc,2);
            this.ValidationRelErrors= zeros(nc,2);
            this.ExpansionSizes= zeros(nc,1);

            /*  Compute initial center */
            [~, this.initialidx] = this.getInitialCenter(atd);

            /*  Start adaptive extension part of subclass */
            kexp = this.startAdaptiveExtension(atd, avd);
        }
        /* % Convenience methods for use/override in concrete algorithms */
    protected:


        function  initExpansion(kernels.KernelExpansion kexp,data.ApproxTrainData atd) {
            kexp.clear;
            this.extendExpansion(kexp, atd, this.initialidx);
            this.Used= this.initialidx;
        }
        function  extendExpansion(kernels.KernelExpansion kexp,data.ApproxTrainData atd,integer idx) {
            kexp.Centers.xi(:,end+1) = atd.xi(:,idx);
            if atd.hasTime
                kexp.Centers.ti(end+1) = atd.ti(idx);
            end
            if atd.hasParams
                kexp.Centers.mui(:,end+1) = atd.mui(:,idx);
            end
            this.Used(end+1) = idx;
        }
        function bool = checkStop(cnt,rel) {
            vb = KerMor.App.Verbose;
            bool = false;
            if cnt == this.MaxExpansionSize
                if vb > 1
                    fprintf(" AAdaptiveBase stopping criteria holds: Max expansion size %d reached.\n ",this.MaxExpansionSize);
                end
                bool = true;
            elseif rel < this.MaxRelErr
                if vb > 1
                    fprintf(" AAdaptiveBase stopping criteria holds: Relative error %.7e < %.7e\n ",rel,this.MaxRelErr);
                end
                bool = true;
            end
        }
    protected: /* ( Abstract ) */

        virtual function  startAdaptiveExtension(kernels.KernelExpansion kexp,data.ApproxTrainData atd) = 0;
    private:

        function [colvecc , integeridx ] = getInitialCenter(data.ApproxTrainData atd) {


            if strcmp(this.InitialCenter," maxfx ")
                [~, idx] = max(this.ErrorFun(atd.fxi));
                c = atd.xi(:,idx);
                if atd.hasTime
                    c = [c; atd.ti(idx)];
                end
                if atd.hasParams
                    c = [c; atd.mui(:,idx)];
                end
            elseif strcmp(this.InitialCenter," center ")
                [c, idx] = atd.getClosestToCenter;
            elseif strcmp(this.InitialCenter," t0 ")
                if atd.hasTime
                    idx = find(atd.ti == 0);
                    if ~isempty(idx)
                        c = [atd.xi(:,idx); zeros(1,numel(idx))];
                        if atd.hasParams
                            c = [c; atd.mui(:,idx)];
                        end
                        if numel(idx) > 1
                            [~,i] = min(sum((c-repmat(atd.Center,1,numel(idx))).^2,1));
                            c = c(:,i);
                            idx = idx(i);
                        end
                    end
                end
            else
                error(" Unknown strategy: %s ",this.InitialCenter);
            end
        }
        /* % Getter & Setter */
    public:

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

#endif


        
#if 0 //mtoc++: 'set.MaxRelErr'
function  MaxRelErr(value) {
            if ~isempty(value) && ~isposrealscalar(value)
                error(" The value must be a positive scalar ");
            end
            this.MaxRelErr= value;
        }

#endif

    
    protected: /* ( Static ) */

        static function this = loadobj(this,initfrom) {
            if nargin > 1
                this.MaxExpansionSize= initfrom.MaxExpansionSize;
                this.InitialCenter= initfrom.InitialCenter;
                if isfield(initfrom," initialidx ")
                    this.initialidx= initfrom.initialidx;
                end
                if isfield(initfrom," Used ")
                    this.Used= initfrom.Used;
                end
                this.ExpansionSizes= initfrom.ExpansionSizes;
                this.InitialCenter= initfrom.InitialCenter;
                this.MaxRelErr= initfrom.MaxRelErr;
                this = loadobj@approx.algorithms.ABase(this, initfrom);
            end
        }

};
}
}