MemoryTrajectoryData.m

Go to the documentation of this file.

namespace data{


/* (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 MemoryTrajectoryData
  :public data.ATrajectoryData {
    public:

        TrajectoryData;
        Parameters;
        InputIndices;
    private:

        hm;
        ctimes;

        
    public:


        MemoryTrajectoryData() {
            if ~usejava(" jvm ")
                error(" MemoryTrajectoryData cannot be used as java is not enabled. ");
            end
            this.hm= java.util.HashMap;
            this.clearTrajectories;
        }


        function [colvec<double>x , doublectime ] = getTrajectory(colvec<double> mu,integer inputidx) {

            if nargin < 3
                inputidx = [];
                if nargin < 2
                    mu = [];
                end
            end

            x = []; ctime = Inf;
            key = Utils.getHash([mu; inputidx]);
            if this.hm.containsKey(key)
                idx = this.hm.get(key);
                x = this.TrajectoryData(:,:,idx);
                ctime = this.ctimes(idx);
            end
        }
        function n = getNumTrajectories() {
           n = size(this.TrajectoryData,3);
        }


        function l = getTotalLength() {
            l = size(this.TrajectoryData,2);
        }


        function [colvec<double>x , colvec<double>mu , integerinputidx , doublectime ] = getTrajectoryNr(nr) {
            if nr > size(this.TrajectoryData,3) || nr < 1
                error(" Invalid trajectory number: %d ",nr);
            end
            x = this.TrajectoryData(:,:,nr);
            mu = [];
            if ~isempty(this.Parameters)
                mu = this.Parameters(:,nr);
            end
            inputidx = [];
            if ~isempty(this.InputIndices)
                inputidx = this.InputIndices(nr);
            end
            ctime = this.ctimes(nr);
        }
        function  addTrajectory(colvec<double> x,colvec<double> mu,integer inputidx,double ctime) {

            if nargin < 4
                inputidx = [];
                if nargin < 3 
                    mu = [];
                end
            end

            if isempty(inputidx) && ~isempty(this.InputIndices)
                error(" MemoryTrajectoryData can only hold TrajectoryData of one type. Having InputIndices and not at the same time is not allowed. ");
            end
            if isempty(mu) && ~isempty(this.Parameters)
                error(" MemoryTrajectoryData can only hold TrajectoryData of one type. Having parameters and not at the same time is not allowed. ");
            end
            if ~isempty(this.TrajectoryData) && (size(x,1) ~= size(this.TrajectoryData,1) || size(x,2) ~= size(this.TrajectoryData,2))
                error(" New trajectory size mismatches the size of already stored TrajectoryData. ");
            end

            key = Utils.getHash([mu; inputidx]);
            if this.hm.containsKey(key)
                warning(" KerMor:MemoryTrajectoryData "," Trajectory already present. Replacing ");
                this.TrajectoryData(:,:,this.hm.get(key)) = x;
            else
                this.TrajectoryData(:,:,end+1) = x;
                if ~isempty(mu)
                    this.Parameters(:,end+1) = mu;
                end
                if ~isempty(inputidx)
                    this.InputIndices(end+1) = inputidx;
                end
                idx = size(this.TrajectoryData,3);
                this.hm.put(key,idx);
                this.ctimes(idx) = ctime;
            end
        }
        function  clearTrajectories() {
            this.TrajectoryData= double.empty(0,0,0);
            this.Parameters= double.empty(0,0);
            this.InputIndices= [];
            this.hm.clear;
            this.ctimes= [];
        }


        function [colvec<double>x , X ] = getBoundingBox() {
            [x, X] = Utils.getBoundingBox(this.TrajectoryData(:,:));
        }


        function [d , mud ] = getTrajectoryDoFs() {
            d = size(this.TrajectoryData,1);
            mud = size(this.Parameters,1);
        }


        function [n , m ] = size(dim) {
            td = this.TrajectoryData;
            n = [size(td,1) size(td,2)*size(td,3)];
            if nargin == 2
                if dim > 0 && dim < 3
                    n = n(dim);
                else
                    n = 0;
                end
            elseif nargout == 2
                m = n(2);
                n = n(1);
            end
        }
        function n = getNumBlocks() {
            n = 1;
        }


        function B = getBlock(unused1) {
            B = reshape(this.TrajectoryData,this.getTrajectoryDoFs,[]);
        }

    
    public: /* ( Static ) */

        static function res = test_MemoryTrajectoryData() {
            
            m = data.MemoryTrajectoryData;

            T = 10;
            res = true;
            for i=1:T;
                tr(:,:,i) = rand(30,50);/* #ok */

                p(:,i) = rand(4,1);/* #ok */

                in(i) = i;/* #ok */

            end

            /*  Params only */
            for i=1:T;
                m.addTrajectory(tr(:,:,i),p(:,i),[],1);
            end
            res = res && m.getNumTrajectories == T;

            for i=1:T;
                [x, pi] = m.getTrajectoryNr(i);
                res = res && isequal(x,tr(:,:,i)) && isequal(p(:,i),pi);
                x = m.getTrajectory(p(:,i),[]);
                res = res && isequal(x,tr(:,:,i));
            end
            m.clearTrajectories;

            /*  Inputs only */
            for i=1:T;
                m.addTrajectory(tr(:,:,i),[],in(i),1);
            end
            res = res && m.getNumTrajectories == T;

            for i=1:T;
                [x, ~, ini] = m.getTrajectoryNr(i);
                res = res && isequal(x,tr(:,:,i)) && isequal(ini,in(i));
                x = m.getTrajectory([],in(i));
                res = res && isequal(x,tr(:,:,i));
            end
            m.clearTrajectories;

            /*  both */
            for i=1:T;
                m.addTrajectory(tr(:,:,i),p(:,i),in(i),1);
            end
            res = res && m.getNumTrajectories == T;

            [U,S] = m.getSVD;/* #ok */


            for i=1:T;
                [x, pi, ini] = m.getTrajectoryNr(i);
                res = res && isequal(x,tr(:,:,i)) && isequal(ini,in(i)) && isequal(p(:,i),pi);
                x = m.getTrajectory(p(:,i),in(i));
                res = res && isequal(x,tr(:,:,i));
            end
            m.clearTrajectories;
        }


};
}