Home > tt2 > @tt_tensor > tt_tensor.m

tt_tensor

PURPOSE ^

TT-tensor constructor

SYNOPSIS ^

function t = tt_tensor(varargin)

DESCRIPTION ^

TT-tensor constructor
   T=TT_TENSOR(ARRAY,EPS) Converts from a full array with accuracy EPS

CROSS-REFERENCE INFORMATION ^

This function calls: This function is called by:

SOURCE CODE ^

0001 function t = tt_tensor(varargin)
0002 %TT-tensor constructor
0003 %   T=TT_TENSOR(ARRAY,EPS) Converts from a full array with accuracy EPS
0004 
0005 %   T=TT_TENSOR(ARRAY,SZ,R1,R2,EPS) Converts from a full array which is
0006 %   treated as an array with mode sizes SZ and tail ranks R1 and R2. The
0007 %   accuracy is set to EPS
0008 %
0009 %   T=TT_TENSOR(TT1) Copies TT1 to TT
0010 %
0011 %   T=TT_TENSOR(TT_MATRIX) Unfolds a TT-matrix into a TT-tensor
0012 %
0013 %   T=TT_TENSOR(TT_ARRAY) Unfolds a TT-array
0014 %
0015 %   T=TT_TENSOR(FILENAME) Reads from the SDV format
0016 %
0017 %   T=TT_TENSOR(CELL_ARRAY) Converts from TT1 format OR
0018 %
0019 %   T=TT_TENSOR(CAN_CELL_ARRAY) Converts from the canonical format, given
0020 %   as a cell array of factors
0021 %
0022 %
0023 % TT-Toolbox 2.2, 2009-2012
0024 %
0025 %This is TT Toolbox, written by Ivan Oseledets et al.
0026 %Institute of Numerical Mathematics, Moscow, Russia
0027 %webpage: http://spring.inm.ras.ru/osel
0028 %
0029 %For all questions, bugs and suggestions please mail
0030 %ivan.oseledets@gmail.com
0031 %---------------------------
0032 
0033 if (nargin == 0)
0034     t.d    = 0;
0035     t.r    = 0;
0036     t.n    = 0;
0037     t.core = 0;                    % empty tensor
0038     t.ps   = 0;
0039     t = class(t, 'tt_tensor');
0040     return;
0041 end
0042 
0043 % Copy CONSTRUCTOR
0044 if (nargin == 1) && isa(varargin{1}, 'tt_tensor')
0045     t = tt_tensor;
0046     t.d = varargin{1}.d;
0047     t.r = varargin{1}.r;
0048     t.n = varargin{1}.n;
0049     t.core=varargin{1}.core;
0050     t.ps = varargin{1}.ps;
0051     return;
0052 end
0053 %From tt_matrix (unfold)
0054 if ( nargin == 1 ) && isa(varargin{1},'tt_matrix');
0055   tm=varargin{1};
0056   t=tm.tt;
0057   return;
0058 end
0059 %From tt_array (stack)
0060 if ( nargin == 1 ) && isa(varargin{1},'tt_array');
0061   ta=varargin{1};
0062   t=ta.tt;
0063   return;
0064 end
0065 %From old format
0066 if ( nargin == 1 ) && isa(varargin{1},'cell') 
0067     %Check if it is a canonical format
0068     tt=varargin{1};
0069     d=numel(tt);
0070     rc=zeros(d,1);
0071     all_2d=true;
0072     for i=1:d
0073        rc=size(tt{i},2);
0074        if (size(tt{i},3) ~= 1 )
0075           all_2d = false;
0076        end
0077     end
0078     if ( numel(unique(rc)) == 1 && all_2d)
0079         is_can = true;
0080         rc=rc(1);
0081     else
0082         is_can = false;
0083     end
0084     if ( ~is_can )  
0085         %t = class(t, 'tt_tensor');
0086        t=tt_tensor;
0087        t.d  = d;
0088        t.r  = tt_ranks(tt);
0089        t.r  = [1;t.r;1];
0090        t.n=tt_size(tt);
0091        t.core=zeros(tt_mem(tt),1);
0092        ps=cumsum([1;t.n.*t.r(1:d).*t.r(2:d+1)]);
0093        %ps=zeros(d+1,1);
0094        t.core(ps(1):ps(2)-1)=tt{1}(:);
0095        for i=2:d-1
0096           cr=tt{i}; cr=permute(cr,[2,1,3]);
0097           t.core(ps(i):ps(i+1)-1) = cr(:);      
0098        end
0099        %t.ps=ps;
0100        cr=tt{d}; cr=permute(cr,[2,1]);
0101        t.core(ps(d):ps(d+1)-1) = cr(:);
0102        t.ps=ps;
0103        return
0104     else
0105        t=tt_tensor;
0106        t.d=d;
0107        r=rc*ones(d+1,1);
0108        r(1)=1; r(d+1)=1;
0109        t.r=r;
0110        n=zeros(d,1);
0111        for i=1:d
0112           n(i)=size(tt{i},1);
0113        end
0114        t.n=n;
0115        t.ps   = cumsum([1;t.n.*t.r(1:t.d).*t.r(2:t.d+1)]);
0116        crp=zeros(t.ps(d+1)-1,1);
0117        cc=tt{1};
0118        crp(t.ps(1):t.ps(2)-1)=cc(:);
0119        cc=tt{d};
0120        cc=cc.';
0121        crp(t.ps(d):t.ps(d+1)-1)=cc(:);
0122        for i=2:d-1
0123           cc=tt{i};
0124           cr=zeros(r(i),n(i),r(i+1));
0125           for j=1:n(i)
0126              cr(:,j,:)=diag(cc(j,:));
0127           end
0128           crp(t.ps(i):t.ps(i+1)-1)=cr(:);
0129        end
0130        t.core=crp;
0131        return
0132     end
0133 end
0134 
0135 % From a simple tt_tensor struct without class definition
0136 if (nargin == 1) && isa(varargin{1}, 'struct')
0137     t.d    = varargin{1}.d;
0138     t.r    = varargin{1}.r;
0139     t.n    = varargin{1}.n;
0140     t.core = varargin{1}.core;                    % empty tensor
0141     t.ps   = cumsum([1;t.n.*t.r(1:t.d).*t.r(2:t.d+1)]);
0142     t = class(t, 'tt_tensor');      
0143     return;
0144 end;
0145 
0146 % From a SDV file
0147 if (nargin == 1) && isa(varargin{1}, 'char')
0148     [d,r,n,core] = tt_read(varargin{1});
0149     
0150     if (d<1)
0151         fprintf('tt_read reported d=%d\n', d);
0152         return;
0153     end;
0154     
0155     t.d = d;
0156     t.r = r;
0157     t.n = n;
0158     t.core = core;
0159     t.ps=cumsum([1;t.n.*t.r(1:d).*t.r(2:d+1)]);
0160     t = class(t, 'tt_tensor');
0161     return
0162 end;
0163 
0164 %From qtt_tucker format
0165 
0166 if ( nargin == 1 && isa(varargin{1}, 'qtt_tucker') )
0167    t=qtttucker_to_tt(varargin{1}.tuck,varargin{1}.core);
0168    return
0169 end
0170 
0171 %From full format
0172 if ( (nargin == 1 && isa(varargin{1},'double')) || (nargin ==2 && isa(varargin{1},'double') && isa(varargin{2},'double')))
0173     t=tt_tensor;
0174     b=varargin{1};
0175     
0176     if ( nargin == 2 && isa(varargin{2},'double')) 
0177       eps=varargin{2};
0178     else
0179       eps=1e-14;
0180       %fprintf('Accuracy not specified, using %3.2e \n',eps);
0181     end
0182     n=size(b); n=n(:); d=numel(n); r=ones(d+1,1);
0183    if ( numel(n) == 2 && n(2) == 1 ) %Singleton tensor
0184      d=1; n=n(1:d);
0185      r=ones(2,1);
0186      core=b(:);
0187      ps=cumsum([1;n.*r(1:d).*r(2:d+1)]);
0188      t.d=d;  
0189      t.n=n;
0190      t.r=r;
0191      t.ps=ps;
0192      t.core=core;
0193      return
0194    end
0195     
0196 end
0197 if ( nargin == 5 && isa(varargin{1},'double')  && isa(varargin{2},'double') && numel(varargin{3})==1  && numel(varargin{4})==1 && numel(varargin{5})==1)
0198    t=tt_tensor;
0199    b=varargin{1}; n=varargin{2}; r(1)=varargin{3}; d=numel(n); r(d+1)=varargin{4}; eps=varargin{5};  
0200 end
0201 d=numel(n);
0202 c=b;
0203 core=[];
0204 pos=1;
0205 ep=eps/sqrt(d-1);
0206 n=n(:); r=r(:);
0207 for i=1:d-1
0208   m=n(i)*r(i); c=reshape(c,[m,numel(c)/m]);
0209   [u,s,v]=svd(c,'econ');
0210   s=diag(s); r1=my_chop2(s,ep*norm(s));
0211   u=u(:,1:r1); s=s(1:r1);
0212   r(i+1)=r1;
0213   core(pos:pos+r(i)*n(i)*r(i+1)-1)=u(:);
0214   v=v(:,1:r1);
0215   v=v*diag(s); c=v';
0216   pos=pos+r(i)*n(i)*r(i+1);
0217 end
0218 core(pos:pos+r(d)*n(d)*r(d+1)-1)=c(:);
0219 core=core(:); 
0220 ps=cumsum([1;n.*r(1:d).*r(2:d+1)]);
0221 t.d=d;
0222 t.n=n;
0223 t.r=r;
0224 t.ps=ps;
0225 t.core=core;
0226 
0227 return;

Generated on Wed 08-Feb-2012 18:20:24 by m2html © 2005