ImprovedLocalSecantLipschitz.m

Go to the documentation of this file.

namespace error{
namespace lipfun{


/* (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 ImprovedLocalSecantLipschitz
  :public error.lipfun.Base {
    public: /* ( setObservable ) */

        UseCachedSecants = false;
    private: /* ( Transient ) */

        oldrs = "[]";

    
    public:

        precomp = "[]";

        
    public:


        ImprovedLocalSecantLipschitz(bellfcn) {
            this = this@error.lipfun.Base(bellfcn);
            this.registerProps(" UseCachedSecants ");
        }


        function copy = clone() {
            copy = error.lipfun.ImprovedLocalSecantLipschitz(this.bellfcn);
            /* copy = clone@error.lipfun.Base(this, copy); */
            copy.UseCachedSecants= this.UseCachedSecants;
        }


        function  prepareConstants() {
        }
        function ci = evaluate(di,C) {
            b = this.bellfcn;
            r0 = b.r0;
            if isempty(this.oldrs) || any(isnan(this.oldrs)) || size(this.oldrs,2) ~= size(di,2)
                this.oldrs= r0+.2*sign(r0-di);
            end

            /*  Consider C=Inf case separately for speed reasons */
            if isinf(C)
                if this.UseCachedSecants
                    rs = this.CachedModifiedNewton(di);
                else
                    rs = b.ModifiedNewton(this.oldrs,di);
                end
                ci = abs(b.evaluateD1(rs));
                this.oldrs= rs;
            else
                rs = ones(size(di))*r0;
                update = abs(di-r0) < C;
                /*  Choose suitable starting conditions if no old rs vectors
                 * are available */
                if any(update)
                    if this.UseCachedSecants
                        rs(update) = this.CachedModifiedNewton(di(update));
                    else
                        rs(update) = b.ModifiedNewton(this.oldrs(update),di(update));
                    end
                    this.oldrs(update) = rs(update);
                end
                left = di + C - rs < 0;
                right = di - C - rs > 0;
                center = ~left & ~right;
                /*  If C is too small we just take the derivative at this
                 * spot */
                if C < sqrt(eps)
                    ci(left | right) = abs(b.evaluateD1(di(left | right)));
                else
                    ci(left) = (b.evaluateScalar((di(left))) - b.evaluateScalar((di(left)+C))) / C;
                    ci(right) = (b.evaluateScalar((di(right)-C)) - b.evaluateScalar((di(right)))) / C;
                end
                ci(center) = abs(b.evaluateD1(rs(center)));
            end
        }


        function  precompMaxSecants(maxDistance,num) {
            if this.UseCachedSecants
                di = linspace(0,maxDistance,num);
                start = this.bellfcn.r0+.2*sign(this.bellfcn.r0-di);
                if KerMor.App.Verbose > 1
                    fprintf(" Precomputing %d max local secants for BellFunction(Gamma=%f,r0=%f) in range [0, %f] ..\n ",num,this.Gamma,this.x0,maxDistance);
                end
                rs = this.bellfcn.ModifiedNewton(start,di);
                t = BinTree;
                if KerMor.App.Verbose > 1
                    fprintf(" Building tree data structure..\n ");
                end
                t.Insert(di,rs);
                this.precomp= t;
            end
        }

    
    private:


        function rs = CachedModifiedNewton(s) {
            if ~isempty(this.precomp)
                t = this.precomp;
                [l,u] = t.FindClosest(s);
                low = s < this.bellfcn.r0;
                rs = zeros(size(y));
                rs(low) = u(low);
                rs(~low) = l(~low);
            else
                error(" When using cached secants the method precompMaxSecants has to be run first. ");
            end
        }


    
    public: /* ( Static ) */


    

};
}
}