AffParamMatrix.m

Go to the documentation of this file.

namespace general{


/* (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 AffParamMatrix
  :public general.AProjectable {
    public:

        integer N = 0;
        Matrices = "[]";
    public:

        .string funStr = {""};
    protected:

        handle cfun = "[]";
        rowvec<integer> dims;
    public:


        function M = compose(t,mu) {
            if this.N == 0
                M = [];
                return;
            end
            M = reshape(this.Matrices * sparse(this.cfun(t,mu)),this.dims(1),[]);
        }
        function c = evalCoeffFun(double t,colvec<double> mu) {
            c = this.cfun(t,mu);
        }


        function copy = clone(copy) {
            if nargin == 1
                copy = general.AffParamMatrix;
            end
            copy = clone@general.AProjectable(this, copy);
            copy.Matrices= this.Matrices;
            copy.N= this.N;
            copy.funStr= this.funStr;
            copy.dims= this.dims;
            copy.funStr= this.funStr;
            copy.cfun= this.cfun;
        }
        function  addMatrix(coeff_fun,mat) {

            if ~isa(coeff_fun," char ")
                error(" Coeff_fun must be a string. ");
            elseif ~isreal(mat)
                error(" Parameter 'mat' must be a real matrix. ");
            end
            if isempty(this.dims)
                this.dims= size(mat);
            end
            this.N= this.N + 1;

            this.funStr[end+1] = coeff_fun;
            /* this.Coefficients{end+1} = coeff_fun; */

            this.Matrices(:,end+1) = mat(:);

            /*  Create the coefficient function */
            this.buildCoeffFun;
        }
        function pr = mtimes(B) {
            if isa(A," general.AffParamMatrix ") && isa(B," general.AffParamMatrix ")
                if ~all(strcmp([class(A),class(B)]," general.AffParamMatrix ")) && ~strcmp(class(A),class(B))
                    warning(" KerMor:Ambiguousclass "," Cannot consistently multiply two real different subclasses of general.AffParamMatrix as the return type is not well defined. ");
                    /* error('Cannot consistently multiply two real different subclasses of general.AffParamMatrix as the return type is not well defined. Please multiply manually.'); */
                end
                if A.dims(2) ~= B.dims(1)
                    error(" Matrix dimensions must agree. ");
                end
                /*  Clone the instance of A as the check above ensures that both  */
                pr = A.clone;
                pr.N= A.N * B.N;
                pr.dims= [A.dims(1) B.dims(2)];
                pr.Matrices= zeros(prod(pr.dims),pr.N);
                pr.funStr= [];
                for i = 1:A.N
                    M = A.getMatrix(i);
                    for j = 1:B.N
                        pr.Matrices(:,(i-1)*B.N + j) = ...
                            reshape(M * B.getMatrix(j),1,[]);
                        pr.funStr[end+1] = [" ( " A.funStr[i] " )*( " B.funStr[j] " ) "];
                    end
                end
                pr.buildCoeffFun;
            elseif isa(A," general.AffParamMatrix ")
                pr = A.clone;
                if isscalar(B)
                    pr.Matrices= B*pr.Matrices;
                else
                    if A.dims(2) ~= size(B,1)
                        error(" Matrix dimensions must agree. ");
                    end
                    pr.dims= [A.dims(1) size(B,2)];
                    pr.Matrices= zeros(prod(pr.dims),pr.N);
                    for i=1:A.N
                        pr.Matrices(:,i) = reshape(...
                            A.getMatrix(i) * B,[],1);
                    end 
                end
            elseif isa(B," general.AffParamMatrix ")
                pr = B.clone;
                if isscalar(A)
                    pr.Matrices= A*pr.Matrices;
                else
                    if size(A,2) ~= B.dims(1)
                        error(" Matrix dimensions must agree. ");
                    end
                    pr.dims= [size(A,1) B.dims(2)];
                    pr.Matrices= zeros(prod(pr.dims),pr.N);
                    for i=1:B.N
                        pr.Matrices(:,i) = reshape(...
                            A * B.getMatrix(i),[],1);
                    end 
                end
            end
        }
        function diff = minus(B) {
            if isa(A," general.AffParamMatrix ") && isa(B," general.AffParamMatrix ")
                if ~all(strcmp([class(A),class(B)]," general.AffParamMatrix ")) && ~strcmp(class(A),class(B))
                    error(" Cannot consistently subtract two real different subclasses of general.AffParamMatrix as the return type is not well defined. Please perform subtraction manually. ");
                end
                if any(A.dims ~= B.dims)
                    error(" Matrix dimensions must agree. ");
                end
                if A.N == B.N && all(strcmp(A.funStr,B.funStr))
                    diff = A.clone;
                    diff.Matrices= A.Matrices - B.Matrices;
                else
                    error(" If two AffParamMatrices are subtracted, the number of elements must be the same and the coefficient functions must match. ");
                end
            elseif isa(A," general.AffParamMatrix ")
                diff = A.clone;
                if isscalar(B)
                    B = ones(size(A.Matrices,1),1)*B;
                end
                diff.addMatrix(" -1 ",B)
            elseif isa(B," general.AffParamMatrix ")
                diff = B.clone;
                diff.Matrices= -diff.Matrices;
                if isscalar(A)
                    A = ones(size(B.Matrices,1),1)*A;
                end
                diff.addMatrix(" 1 ",A);
            end
        }
        function transp = ctranspose() {
            transp = this.clone;
            transp.dims= fliplr(transp.dims);
            /*  Autodetects size & type of projected matrix! */
            if this.N > 0
                transp.Matrices= reshape(this.getMatrix(1)^t,[],1);
            end
            for i=2:this.N
                transp.Matrices(:,i) = reshape(this.getMatrix(i)^t,[],1);
            end
        }
        function dotprod = times(B) {
            if isa(A," general.AffParamMatrix ") && isa(B," general.AffParamMatrix ")
                error(" Not yet implemented ");
            elseif isa(A," general.AffParamMatrix ")
                dotprod = A.clone;
                dotprod.Matrices= A.Matrices .* repmat(B(:),1,A.N);
            elseif isa(B," general.AffParamMatrix ")
                dotprod = B.times(A);
            end
        }


        function M = getMatrix(idx) {
            if idx > this.N
                error(" Invalid index %d. Max index is %d. ",idx,this.N);
            end
            M = reshape(this.Matrices(:,idx),this.dims);
        }
        function general.AffParamMatrixtarget = project(matrix<double> V,matrix<double> W,general.AffParamMatrix target) {

            if isempty(V) || isempty(W)
                error(" Both V and W must be given and nonempty (Set either to 1 for neutral as required). ");
            end
            if nargin < 4
                target = this.clone;
            end
            if ~isequal(V,1)
                target.dims(2) = size(V,2);
            end
            if ~isequal(W,1)
                target.dims(1) = size(W,2);
            end
            /*  Autodetects size & type of projected matrix! */
            if this.N > 0
                target.Matrices= reshape(W^t*(this.getMatrix(1)*V),[],1);
            end
            for idx=2:this.N
                target.Matrices(:,idx) = reshape(W^t*(this.getMatrix(idx)*V),[],1);
            end
        }
        function [n , m ] = size(dim) {
            n = this.dims;
            if nargin == 2
                if dim > 0 && dim < 3
                    n = n(dim);
                else
                    n = 0;
                end
            elseif nargout == 2
                n = this.dims(1);
                m = this.dims(2);
            end
        }
        function  clear() {
            this.N= 0;
            this.Matrices= [];
            this.cfun= [];
            this.dims= [];
            this.funStr= [];
        }

    
    private:

        function  buildCoeffFun() {
            this.cfun= eval([" @(t,mu)[ " Utils.implode(this.funStr," ;  ") " ] "]);
        }
};
}