ABase.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 ABase
  :public KerMorObject,
   public ICloneable,
   public IReductionSummaryPlotProvider {
    public: /* ( setObservable ) */

        kernels.config.ExpansionConfig ExpConfig = "[]";
        UsefScaling = false;
        function_handle ErrorFun = @Norm.L2;
    public:

        double LastCompTime = "[]";
        matrix<double> MaxErrors = "[]";
        matrix<double> MaxRelErrors = "[]";
        matrix<double> ValidationErrors = "[]";
        matrix<double> ValidationRelErrors = "[]";
        matrix<integer> StopFlags = "[]";
    public:

        integer BestExpConfig;
    protected:

        ScalingG;
    public:

        ABase() {
            this = this@KerMorObject;

            this.registerProps(" ExpConfig "," UsefScaling ");
        }


        function copy = clone(copy) {
            if ~isempty(this.ExpConfig)
                copy.ExpConfig= this.ExpConfig.clone;
            end
            copy.UsefScaling= this.UsefScaling;
            copy.ErrorFun= this.ErrorFun;
            copy.MaxErrors= this.MaxErrors;
            copy.MaxRelErrors= this.MaxRelErrors;
            copy.ValidationErrors= this.ValidationErrors;
            copy.ValidationRelErrors= this.ValidationRelErrors;
            copy.LastCompTime= this.LastCompTime;
            copy.StopFlags= this.StopFlags;
            copy.ScalingG= this.ScalingG;
            copy.BestExpConfig= this.BestExpConfig;
        }


        function kernels.KernelExpansionkexp = computeApproximation(data.ApproxTrainData atd,avd) {
            time = tic;

            if nargin < 3
                avd = atd;
            end

            if isempty(this.ExpConfig)
                error(" No ExpConfig set. Aborting. ");
            elseif this.ExpConfig.getNumConfigurations == 0
                error(" Need at least one expansion configuration. ");
            end

            /*  Scale f-values if wanted */
            if this.UsefScaling
                [fm,fM] = atd.fxi.getColBoundingBox;
                s = max(abs(fm),abs(fM));
                s(s==0) = 1;
                oldfxi = atd.fxi.toMemoryMatrix;
                oldvalfxi = avd.fxi.toMemoryMatrix;
                atd.fxi(:,:) = oldfxi ./ repmat(s,1,size(atd.fxi,2));
                /*  Apply same scaling to validation data */
                if nargin > 2
                    avd.fxi(:,:) = oldvalfxi ./ repmat(s,1,size(avd.fxi,2));
                end
                this.ScalingG= diag(s);
            else
                this.ScalingG= 1;
            end

            /*  Call template method for component wise approximation */
            kexp = this.templateComputeApproximation(atd, avd);

            /*  Rescale if set */
            if this.UsefScaling
                kexp.Ma= this.ScalingG*kexp.Ma;
                atd.fxi(:,:) = oldfxi;
                if nargin > 2
                    avd.fxi(:,:) = oldvalfxi;
                end
            end

            /*  Reduce the snapshot array and coeff data to the
             * really used ones! This means if any snapshot x_n is
             * not used in any dimension, it is kicked out at this
             * stage. */
            n = size(kexp.Centers.xi,2);
            hlp = sum(abs(kexp.Ma) ~= 0,1);
            usedidx = find(hlp > 0);
            /*  If all is zero, create a zero approx with one center and zero
             * coefficient */
            if isempty(usedidx)
                usedidx = 1;
            end
            if length(usedidx) < n
                kexp.Ma= kexp.Ma(:,usedidx);
                kexp.Centers.xi= kexp.Centers.xi(:,usedidx);
                if isfield(kexp.Centers," ti ") && ~isempty(kexp.Centers.ti)
                    kexp.Centers.ti= kexp.Centers.ti(:,usedidx);
                end
                if isfield(kexp.Centers," mui ") && ~isempty(kexp.Centers.mui)
                    kexp.Centers.mui= kexp.Centers.mui(:,usedidx);
                end
            end

            /*  Create sparse representation if many elements are zero */
            if sum(hlp) / numel(kexp.Ma) < .5
                kexp.Ma= sparse(kexp.Ma);
            end
            this.LastCompTime= toc(time);
        }


        function [str , rangetab ] = getApproximationSummary() {
            str = [object2str(this,1) char(13)];

            ec = this.ExpConfig;
            /*  Computation time */
            str = [str sprintf(" Total computation time for %d configurations: %gs (%gmin,%gh)\n ",...
                ec.getNumConfigurations,this.LastCompTime,...
                this.LastCompTime/60,this.LastCompTime/3600)];
            /*  Configuration */
            str = [str sprintf(" Best expansion configuration at index %d:\n%s\n ",this.BestExpConfig,...
                ec.getConfigurationString(this.BestExpConfig))];
            rangetab = ec.getValueRanges;
            if nargout < 2
                str = [str sprintf(" Expansion configuration ranges:\n%s\n ",...
                    rangetab.toString)];
                if nargout < 1
                    disp(str);
                end
            end
        }
        function  plotSummary(pm,context) {
            if nargin < 3
                context = " Summary ";
                if nargin < 2
                    pm = PlotManager(false,1,2);
                    pm.LeaveOpen= true;
                end
            end

            str = sprintf(" %s: Max absolute training errors ",context);
            h = pm.nextPlot(" maxerrors ",str,...
                " expansion size "," error ");
            ph = semilogy(h,1:size(this.MaxErrors,2),this.MaxErrors^t);
            if ~isempty(this.ExpConfig)
                set(ph(this.BestExpConfig)," LineWidth ",2);
            end
            str = sprintf(" %s: Max relative training errors ",context);
            h = pm.nextPlot(" maxrelerrors ",str,...
                " expansion size "," error ");
            ph = semilogy(h,1:size(this.MaxRelErrors,2),this.MaxRelErrors^t);
            if ~isempty(this.ExpConfig)
                set(ph(this.BestExpConfig)," LineWidth ",2);
            end
            str = sprintf(" %s: Absolute validation errors ",context);
            h = pm.nextPlot(" valerrors ",str,...
                " configuration nr "," error ");
            semilogy(h,1:length(this.ValidationErrors),this.ValidationErrors);
            legend(" max "," mean ");

            str = sprintf(" %s: Relative validation errors ",context);
            h = pm.nextPlot(" valrelerrors ",str,...
                " configuration nr "," error ");
            semilogy(h,1:length(this.ValidationRelErrors),this.ValidationRelErrors);
            legend(" max "," mean ");


            if nargin < 2
                pm.done;
            end
        }


        function nc = getTotalNumConfigurations() {
            nc = 1;
            if ~isempty(this.ExpConfig)
                nc = this.ExpConfig.StateConfig.getNumConfigurations;
            end
        }

    
    protected:

        function [doubleval , integeridx , rowvecerrs ] = getError(kernels.KernelExpansion kexp,data.ApproxTrainData atd) {
            e = atd.fxi - kexp.evaluate(atd.xi, atd.ti, atd.mui);
            errs = this.ErrorFun(this.ScalingG*e);
            [val, idx] = max(errs);
        }
    protected: /* ( Abstract ) */

        virtual function  templateComputeApproximation(kernels.KernelExpansion kexp,data.ApproxTrainData atd,avd) = 0;
     protected: /* ( Static ) */

        static function this = loadobj(this,initfrom) {
            if nargin > 1
                this.ErrorFun= initfrom.ErrorFun;
                this.LastCompTime= initfrom.LastCompTime;
                this.UsefScaling= initfrom.UsefScaling;
                if isfield(initfrom," ExpConfig ")
                    this.ExpConfig= initfrom.ExpConfig;
                end
                if isfield(initfrom," MaxErrors ") && ~isempty(initfrom.MaxErrors)
                    this.MaxErrors= initfrom.MaxErrors;
                elseif isfield(initfrom," err ")
                    this.MaxErrors= initfrom.err;
                end
                if isfield(initfrom," MaxRelErrors ") && ~isempty(initfrom.MaxRelErrors)
                    this.MaxRelErrors= initfrom.MaxRelErrors;
                elseif isfield(initfrom," relerr ")
                    this.MaxRelErrors= initfrom.relerr;
                end
                if isfield(initfrom," ValidationErrors ") && ~isempty(initfrom.ValidationErrors)
                    this.ValidationErrors= initfrom.ValidationErrors;
                end
                if isfield(initfrom," ValidationRelErrors ") && ~isempty(initfrom.ValidationRelErrors)
                    this.ValidationRelErrors= initfrom.ValidationRelErrors;
                end
                if ~isfield(initfrom," StopFlags ") || isempty(initfrom.StopFlags)
                    this.StopFlags= zeros(size(this.MaxErrors));
                end
                this = loadobj@KerMorObject(this, initfrom);
            else
                if isempty(this.StopFlags)
                    this.StopFlags= zeros(size(this.MaxErrors));
                end
                this = loadobj@KerMorObject(this);
            end
        }


};
}
}