├── LICENSE ├── README.md ├── images └── simonbaker.png ├── matlab ├── LBPimages.m ├── affineFit.m ├── checkGoodPerturbedBox.m ├── composeWarp.m ├── computeBiasFeature.m ├── computeLKregressor.m ├── compute_dRdg.m ├── compute_dRdg1k.m ├── compute_dxdp.m ├── extractFeature.m ├── genNoiseWarp.m ├── getFileLists.m ├── getLKICregressors.m ├── getStats1frame.m ├── getStats1layer.m ├── image2Im.m ├── performRegression.m ├── read1file.m ├── runTest.m ├── runTrain.m ├── setParams.m ├── solveRegressor1layer.m ├── solve_SDM.m ├── solve_condLK.m ├── solve_genLK.m ├── visualizeGradients.m ├── visualizeWarp.m ├── warpImage.m ├── warpMtrx2Vec.m └── warpVec2Mtrx.m └── mtimesx_20110223 ├── license.txt ├── mtimesx.c ├── mtimesx.m ├── mtimesx.mexa64 ├── mtimesx_20110223.pdf ├── mtimesx_RealTimesReal.c ├── mtimesx_build.m ├── mtimesx_sparse.m ├── mtimesx_test_ddequal.m ├── mtimesx_test_ddspeed.m ├── mtimesx_test_dsequal.m ├── mtimesx_test_dsspeed.m ├── mtimesx_test_nd.m ├── mtimesx_test_sdequal.m ├── mtimesx_test_sdspeed.m ├── mtimesx_test_ssequal.m └── mtimesx_test_ssspeed.m /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2018 Chen-Hsuan Lin 4 | 5 | Permission is hereby granted, free of charge, to any person obtaining a copy 6 | of this software and associated documentation files (the "Software"), to deal 7 | in the Software without restriction, including without limitation the rights 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell 9 | copies of the Software, and to permit persons to whom the Software is 10 | furnished to do so, subject to the following conditions: 11 | 12 | The above copyright notice and this permission notice shall be included in all 13 | copies or substantial portions of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, 20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE 21 | SOFTWARE. 22 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | ## The Conditional Lucas & Kanade Algorithm 2 | [Chen-Hsuan Lin](https://chenhsuanlin.bitbucket.io/), 3 | [Rui Zhu](https://jerrypiglet.github.io/), 4 | and [Simon Lucey](http://www.simonlucey.com/) 5 | European Conference on Computer Vision (ECCV), 2016 6 | 7 | Project page: https://chenhsuanlin.bitbucket.io/conditional-LK 8 | Paper: https://chenhsuanlin.bitbucket.io/conditional-LK/paper.pdf 9 | Poster: https://chenhsuanlin.bitbucket.io/conditional-LK/poster.pdf 10 | 11 | We provide the MATLAB code for planar image alignment experiments. 12 | 13 | -------------------------------------- 14 | 15 | ### Prerequisites 16 | You would need to first compile [MTIMESX](https://www.mathworks.com/matlabcentral/fileexchange/25977-mtimesx-fast-matrix-multiply-with-multi-dimensional-support). This is required for fast computation for optimizing Conditional LK. Please follow the instructions in the MATLAB File Exchange to compile this library. 17 | 18 | ### Running the code 19 | 20 | To train the linear regressors, run `runTrain` under the matlab directory. 21 | Run `runTest` to evaluate the trained regressors. 22 | There is also a number of different parameters that can be adjusted for the experiment in setParams.m. 23 | 24 | The nonlinear optimization methods we provide include: 25 | * Levenberg-Marquardt using the MATLAB built-in `lsqnonlin` function 26 | * Gauss-Newton with GPU support 27 | * Levenberg-Marquardt with GPU support 28 | * Vanilla gradient descent 29 | * Limited-memory BFGS (LBFGS) 30 | 31 | **(new)** We have additionaly included support using the [minFunc](https://www.cs.ubc.ca/~schmidtm/Software/minFunc.html) library if you wish to use LBFGS for optimization (nice if you have limited RAM). Other optimization methods in *minFunc* are also compatible. 32 | We did not use *minFunc* for our experiments, but if you wish to use it, please place the `minFunc_2012` directory in the repository root and follow the instructions to compile. 33 | 34 | We also provide a script `visualizeGradients.m` to help visualize the learned gradients. You would need [imdisp](https://www.mathworks.com/matlabcentral/fileexchange/22387-imdisp) to run this script. 35 | 36 | -------------------------------------- 37 | 38 | If you find our code useful for your research, please cite 39 | ``` 40 | @inproceedings{lin2016conditional, 41 | title={The Conditional Lucas \& Kanade Algorithm}, 42 | author={Lin, Chen-Hsuan and Zhu, Rui and Lucey, Simon}, 43 | booktitle={European Conference on Computer Vision (ECCV)}, 44 | pages={793--808}, 45 | year={2016}, 46 | organization={Springer International Publishing} 47 | } 48 | ``` 49 | Please contact me (chlin@cmu.edu) if you have any questions! 50 | 51 | 52 | -------------------------------------------------------------------------------- /images/simonbaker.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenhsuanlin/conditional-LK/ecd86d3c00e563cbe5e658fc268628c4acbff5c3/images/simonbaker.png -------------------------------------------------------------------------------- /matlab/LBPimages.m: -------------------------------------------------------------------------------- 1 | % Extract LBP feature 2 | function LBP = LBPimages(image,params) 3 | 4 | image = imfilter(image,params.LBP_gaussianKernel); 5 | LBPimage = zeros(size(image,1),size(image,2),8); 6 | c = params.LBP_compareDist; 7 | LBPimage(1+c:end-c,1+c:end-c,1) = image(1+c:end-c,1+c:end-c)>image(1:end-c*2,1:end-c*2); 8 | LBPimage(1+c:end-c,1+c:end-c,2) = image(1+c:end-c,1+c:end-c)>image(1:end-c*2,1+c:end-c); 9 | LBPimage(1+c:end-c,1+c:end-c,3) = image(1+c:end-c,1+c:end-c)>image(1:end-c*2,1+c*2:end); 10 | LBPimage(1+c:end-c,1+c:end-c,4) = image(1+c:end-c,1+c:end-c)>image(1+c:end-c,1+c*2:end); 11 | LBPimage(1+c:end-c,1+c:end-c,5) = image(1+c:end-c,1+c:end-c)>image(1+c*2:end,1+c*2:end); 12 | LBPimage(1+c:end-c,1+c:end-c,6) = image(1+c:end-c,1+c:end-c)>image(1+c*2:end,1+c:end-c); 13 | LBPimage(1+c:end-c,1+c:end-c,7) = image(1+c:end-c,1+c:end-c)>image(1+c*2:end,1:end-c*2); 14 | LBPimage(1+c:end-c,1+c:end-c,8) = image(1+c:end-c,1+c:end-c)>image(1+c:end-c,1:end-c*2); 15 | LBP = image2Im(LBPimage,params); 16 | -------------------------------------------------------------------------------- /matlab/affineFit.m: -------------------------------------------------------------------------------- 1 | % Fit an affine warp 2 | function affineWarpMtrx = affineFit(Xsrc,Xdst) 3 | 4 | assert(size(Xsrc,2) = = size(Xdst,2)); 5 | N = size(Xsrc,2); 6 | X = Xsrc(1,:)'; 7 | Y = Xsrc(2,:)'; 8 | U = Xdst(1,:)'; 9 | V = Xdst(2,:)'; 10 | O = zeros(N,1); 11 | I = ones(N,1); 12 | A = [X,Y,O,O,I,O;... 13 | O,O,X,Y,O,I]; 14 | b = [U;V]; 15 | p = A\b; 16 | affineWarpMtrx = [p(1),p(2),p(5);... 17 | p(3),p(4),p(6);... 18 | 0, 0, 1]; 19 | -------------------------------------------------------------------------------- /matlab/checkGoodPerturbedBox.m: -------------------------------------------------------------------------------- 1 | % Make sure perturbed box doesn't fall out of image 2 | function good = checkGoodPerturbedBox(params,pVec,image) 3 | 4 | % warp the box 5 | pMtrx = warpVec2Mtrx(params,pVec); 6 | W = params.ImW; 7 | H = params.ImH; 8 | ImBox = [-W/2,-W/2,W/2,W/2,-W/2; 9 | -H/2,H/2,H/2,-H/2,-H/2]; 10 | warpImBox = pMtrx*[ImBox;[1,1,1,1,1]]; 11 | warpImBox(1,:) = warpImBox(1,:)./warpImBox(3,:); 12 | warpImBox(2,:) = warpImBox(2,:)./warpImBox(3,:); 13 | warpImBox(3,:) = 1; 14 | warpImageBox = params.Im2imageAffine*warpImBox; 15 | % check if warped box still lies inside image 16 | [imageH,imageW,~] = size(image); 17 | fail = (warpImageBox(1,:)<1|warpImageBox(1,:)>imageW)|... 18 | (warpImageBox(2,:)<1|warpImageBox(2,:)>imageH); 19 | good = (sum(fail)==0); 20 | -------------------------------------------------------------------------------- /matlab/composeWarp.m: -------------------------------------------------------------------------------- 1 | % update warp (compositional) 2 | function pVec = composeWarp(pVec,dpVec,params,inverse) 3 | 4 | pMtrx = warpVec2Mtrx(params,pVec); 5 | dpMtrx = warpVec2Mtrx(params,dpVec); 6 | if(inverse) 7 | pMtrx = dpMtrx\pMtrx; 8 | else 9 | pMtrx = dpMtrx*pMtrx; 10 | end 11 | pVec = warpMtrx2Vec(params,pMtrx); 12 | -------------------------------------------------------------------------------- /matlab/computeBiasFeature.m: -------------------------------------------------------------------------------- 1 | % Precompute bias feature 2 | function featGTvec = computeBiasFeature(imageAll,params) 3 | 4 | fprintf('precomputing bias feature... \n'); 5 | featGTall = zeros(params.featDim,params.imageN); 6 | for i = 1:params.imageN 7 | % read one image 8 | image = double(rgb2gray(imageAll{i})); 9 | featGT = extractFeature(image,params); 10 | featGTall(:,i) = featGT(:); 11 | end 12 | featGTvec = mean(featGTall,2); 13 | -------------------------------------------------------------------------------- /matlab/computeLKregressor.m: -------------------------------------------------------------------------------- 1 | % Compute Lucas-Kanade regressor 2 | function R = computeLKregressor(params,g) 3 | 4 | D = params.ImDim; 5 | K = params.featChan; 6 | dxdp = compute_dxdp(params); 7 | gi = repmat([1:D*K],[1,2]); 8 | gj = [repmat([1:D],[1,K]),repmat([D+1:2*D],[1,K])]; 9 | G = sparse(gi,gj,g); 10 | R = pinv(G*dxdp); 11 | -------------------------------------------------------------------------------- /matlab/compute_dRdg.m: -------------------------------------------------------------------------------- 1 | % Compute Jacobian of regressor R given g 2 | function dRdg = compute_dRdg(g,params) 3 | 4 | addpath('../mtimesx_20110223/'); 5 | P = params.pDim; 6 | D = params.ImDim; 7 | K = params.featChan; 8 | % precompute variables 9 | dxdp = compute_dxdp(params); 10 | dxdpX = dxdp(1:D,:); 11 | dxdpY = dxdp(D+1:end,:); 12 | dxdpXrepmatK = repmat(dxdpX,[K,1]); 13 | dxdpYrepmatK = repmat(dxdpY,[K,1]); 14 | gi = repmat([1:D*K],[1,2]); 15 | gj = [repmat([1:D],[1,K]),repmat([D+1:2*D],[1,K])]; 16 | G = sparse(gi,gj,g); 17 | G_dxdp = G*dxdp; 18 | invH = inv(G_dxdp'*G_dxdp); 19 | % compute Jacobian with respect to g 20 | dGdg_dxdp = [dxdpXrepmatK;dxdpYrepmatK]; 21 | dHdg1term = mtimesx(permute([G_dxdp;G_dxdp],[2,3,1]),... 22 | permute(dGdg_dxdp,[3,2,1])); 23 | dHdg = dHdg1term+permute(dHdg1term,[2,1,3]); 24 | dinvHdg = -mtimesx(invH,mtimesx(dHdg,invH)); 25 | dRdg = mtimesx(dinvHdg,G_dxdp'); 26 | dRdg2diagX = dxdpXrepmatK*invH; 27 | dRdg2diagY = dxdpYrepmatK*invH; 28 | for p = 1:P 29 | idxX = [(P*D*K)*[0:D*K-1]+P*[0:D*K-1]+p]; 30 | idxY = [P*D*K*D*K+(P*D*K)*[0:D*K-1]+P*[0:D*K-1]+p]; 31 | dRdg(idxX) = dRdg(idxX)+dRdg2diagX(:,p)'; 32 | dRdg(idxY) = dRdg(idxY)+dRdg2diagY(:,p)'; 33 | end 34 | -------------------------------------------------------------------------------- /matlab/compute_dRdg1k.m: -------------------------------------------------------------------------------- 1 | % Compute Jacobian of regressor R given g (for a single channel) 2 | function dRdg1k = compute_dRdg1k(g,k,params) 3 | 4 | addpath('../mtimesx_20110223/'); 5 | P = params.pDim; 6 | D = params.ImDim; 7 | K = params.featChan; 8 | % precompute variables 9 | dxdp = compute_dxdp(params); 10 | dxdpX = dxdp(1:D,:); 11 | dxdpY = dxdp(D+1:end,:); 12 | gi = repmat([1:D*K],[1,2]); 13 | gj = [repmat([1:D],[1,K]),repmat([D+1:2*D],[1,K])]; 14 | G = sparse(gi,gj,g); 15 | G_dxdp = G*dxdp; 16 | invH = inv(G_dxdp'*G_dxdp); 17 | % compute Jacobian with respect to g 18 | dGdg_dxdp = dxdp; 19 | dHdg1term = mtimesx(permute([G_dxdp((k-1)*D+[1:D],:);... 20 | G_dxdp((k-1)*D+[1:D],:)],[2,3,1]),... 21 | permute(dGdg_dxdp,[3,2,1])); 22 | dHdg = dHdg1term+permute(dHdg1term,[2,1,3]); 23 | dinvHdg = -mtimesx(invH,mtimesx(dHdg,invH)); 24 | dRdg1k = mtimesx(dinvHdg,G_dxdp'); 25 | dRdg2diagX = dxdpX*invH; 26 | dRdg2diagY = dxdpY*invH; 27 | for p = 1:P 28 | idxX = [P*(k-1)*D+(P*D*K)*[0:D-1]+P*[0:D-1]+p]; 29 | idxY = [P*(k-1)*D+P*D*D*K+(P*D*K)*[0:D-1]+P*[0:D-1]+p]; 30 | dRdg1k(idxX) = dRdg1k(idxX)+dRdg2diagX(:,p)'; 31 | dRdg1k(idxY) = dRdg1k(idxY)+dRdg2diagY(:,p)'; 32 | end 33 | -------------------------------------------------------------------------------- /matlab/compute_dxdp.m: -------------------------------------------------------------------------------- 1 | % Compute warp Jacobian 2 | function dxdp = compute_dxdp(params) 3 | 4 | [u,v] = meshgrid(1:params.ImW,1:params.ImH); 5 | u = u-params.ImW/2; 6 | v = v-params.ImH/2; 7 | U = u(:); 8 | V = v(:); 9 | O = zeros(params.ImDim,1); 10 | I = ones(params.ImDim,1); 11 | switch(params.warpType) 12 | case 'T', % translation 13 | dxdp = [I,O;... 14 | O,I]; 15 | case 'R', % rigid, TODO 16 | case 'S', % similarity 17 | dxdp = [U,-V,I,O;... 18 | V, U,O,I]; 19 | case 'A', % affine 20 | dxdp = [U,V,O,O,I,O;... 21 | O,O,U,V,O,I]; 22 | case 'H', % homography 23 | dxdp = [U,V,I,O,O,O,-U.*U,-V.*U;... 24 | O,O,O,U,V,I,-U.*V,-V.*V]; 25 | otherwise, dxdp = []; 26 | end 27 | -------------------------------------------------------------------------------- /matlab/extractFeature.m: -------------------------------------------------------------------------------- 1 | % Extract (feature) image 2 | function feat = extractFeature(image,params) 3 | 4 | switch(params.featType) 5 | case 'pixel', 6 | feat = image2Im(image,params); 7 | case 'LBP', 8 | feat = LBPimages(image,params); 9 | otherwise, 10 | end 11 | 12 | -------------------------------------------------------------------------------- /matlab/genNoiseWarp.m: -------------------------------------------------------------------------------- 1 | % Generate a random warp 2 | function dpVec = genNoiseWarp(params) 3 | 4 | warpScale = params.warpScale; 5 | % perturb the four corners of the box 6 | W = params.ImW; 7 | H = params.ImH; 8 | dX = W*warpScale.pert*randn(4,1)+W*warpScale.trans*randn(); 9 | dY = H*warpScale.pert*randn(4,1)+H*warpScale.trans*randn(); 10 | X = [-W/2;W/2;W/2;-W/2]; 11 | Y = [-H/2;-H/2;H/2;H/2]; 12 | O = zeros(4,1); 13 | I = ones(4,1); 14 | switch(params.warpType) 15 | case 'T', % translation 16 | J = [I,O;... 17 | O,I]; 18 | dpVec = J\[dX;dY]; 19 | case 'R', % rigid, TODO 20 | case 'S', % similarity 21 | J = [X,-Y,I,O;... 22 | Y, X,O,I]; 23 | dpVec = J\[dX;dY]; 24 | case 'A', % affine 25 | J = [X,Y,O,O,I,O;... 26 | O,O,X,Y,O,I]; 27 | dpVec = J\[dX;dY]; 28 | case 'H', % homography 29 | Xp = X+dX; 30 | Yp = Y+dY; 31 | A = [X,Y,I,O,O,O,-X.*Xp,-Y.*Xp;... 32 | O,O,O,X,Y,I,-X.*Yp,-Y.*Yp]; 33 | h = A\[Xp;Yp]; 34 | dpVec = h-[1;0;0;0;1;0;0;0]; 35 | otherwise, dpVec = []; 36 | end 37 | assert(length(dpVec) = = params.pDim); 38 | 39 | -------------------------------------------------------------------------------- /matlab/getFileLists.m: -------------------------------------------------------------------------------- 1 | % Load images for each frame 2 | function [imlst,lmlst] = getFileLists(path,seq) 3 | 4 | % read image filelist 5 | fid = fopen([path,'/',seq,'_imlst.txt'],'r'); 6 | imlstCell = textscan(fid,'%s'); 7 | imlst = imlstCell{1}; 8 | fclose(fid); 9 | % read landmark filelist 10 | fid = fopen([path,'/',seq,'_lmlst.txt'],'r'); 11 | lmlstCell = textscan(fid,'%s'); 12 | lmlst = lmlstCell{1}; 13 | fclose(fid); 14 | 15 | -------------------------------------------------------------------------------- /matlab/getLKICregressors.m: -------------------------------------------------------------------------------- 1 | % get the inverse-compositional LK regressors 2 | function Rall = getLKICregressors(params,layerMaxN) 3 | 4 | featGT = reshape(params.featGTvec,[params.ImH,params.ImW,params.featChan]); 5 | [featGTgradx,featGTgrady] = gradient(featGT); 6 | g = [featGTgradx(:);featGTgrady(:)]; 7 | R = computeLKregressor(params,g); 8 | R = [R,-R*params.featGTvec]; 9 | Rall = cell(layerMaxN,1); 10 | for l = 1:length(Rall) 11 | Rall{l} = R; 12 | end 13 | -------------------------------------------------------------------------------- /matlab/getStats1frame.m: -------------------------------------------------------------------------------- 1 | % Collect statistics of 1 frame for training 2 | function [dp1frameVec,feat1frameVec] = getStats1frame(image,Rall,params) 3 | 4 | dp1frame = zeros(params.pDim,params.exampleN+params.validationN); 5 | feat1frame = zeros(params.featDim,params.exampleN+params.validationN); 6 | warpHandle = []; 7 | for e = 1:params.exampleN+params.validationN 8 | % sample a perturbation 9 | while(true) 10 | dpVecNoise = genNoiseWarp(params); 11 | % make sure perturbed box doesn't fall out of image 12 | if(checkGoodPerturbedBox(params,dpVecNoise,image)) break; end 13 | end 14 | % regress with the given regressors 15 | [dpVecAll,featVec] = performRegression(params,image,dpVecNoise,Rall,false); 16 | dpVec = dpVecAll(end,:)'; 17 | % visualization 18 | if(params.visualizeTrain) 19 | warpHandle = visualizeWarp(image,dpVec,params,warpHandle); 20 | drawnow; 21 | end 22 | % add to statistics 23 | dp1frame(:,e) = dpVec; 24 | feat1frame(:,e) = featVec; 25 | end 26 | dp1frameVec = dp1frame(:); 27 | feat1frameVec = feat1frame(:); 28 | -------------------------------------------------------------------------------- /matlab/getStats1layer.m: -------------------------------------------------------------------------------- 1 | % Get statistics for 1 layer of regressor 2 | function [trainData,validData] = getStats1layer(imageAll,boxGTall,Rall,params) 3 | 4 | % collect statistics 5 | fprintf('collecting data... '); 6 | timeStats = tic; 7 | pDim = params.pDim; 8 | featDim = params.featDim; 9 | exampleN = params.exampleN; 10 | validationN = params.validationN; 11 | imageN = params.imageN; 12 | dpTrainAll = zeros(pDim*exampleN,imageN); 13 | dpValidAll = zeros(pDim*validationN,imageN); 14 | featTrainAll = zeros(featDim*exampleN,imageN); 15 | featValidAll = zeros(featDim*validationN,imageN); 16 | for i = 1:imageN 17 | image = imageAll{i}; 18 | boxGT = boxGTall{i}; 19 | [dp1frameVec,feat1frameVec] = getStats1frame(image,Rall,params); 20 | dp1frameTrainVec = dp1frameVec(1:pDim*exampleN); 21 | dp1frameValidVec = dp1frameVec(pDim*exampleN+1:end); 22 | feat1frameTrainVec = feat1frameVec(1:featDim*exampleN); 23 | feat1frameValidVec = feat1frameVec(featDim*exampleN+1:end); 24 | dpTrainAll(:,i) = dp1frameTrainVec; 25 | dpValidAll(:,i) = dp1frameValidVec; 26 | featTrainAll(:,i) = feat1frameTrainVec; 27 | featValidAll(:,i) = feat1frameValidVec; 28 | end 29 | trainData.dpAll = reshape(dpTrainAll,[pDim,exampleN]); 30 | trainData.featDall = reshape(featTrainAll,[featDim,exampleN]); 31 | validData.dpAll = reshape(dpValidAll,[pDim,validationN]); 32 | validData.featDall = reshape(featValidAll,[featDim,validationN]); 33 | % subtract the image samples by the bias 34 | trainData.featDall = bsxfun(@minus,trainData.featDall,params.featGTvec); 35 | validData.featDall = bsxfun(@minus,validData.featDall,params.featGTvec); 36 | fprintf('done (time = %fsec)\n',toc(timeStats)); 37 | 38 | -------------------------------------------------------------------------------- /matlab/image2Im.m: -------------------------------------------------------------------------------- 1 | % Gets the appearance from the original image 2 | function Im = image2Im(image,params) 3 | 4 | boxGT = params.boxGT; 5 | imageBbox = image(boxGT(2):boxGT(4),boxGT(1):boxGT(3),:); 6 | Im = imresize(imageBbox,[params.ImW,params.ImH]); 7 | -------------------------------------------------------------------------------- /matlab/performRegression.m: -------------------------------------------------------------------------------- 1 | % Run through the regressors 2 | function [pVecAll,featVec] = performRegression(params,image,pVec,Rall,visualize) 3 | 4 | % visualization 5 | warpHandle = []; 6 | if(visualize) 7 | warpHandle = visualizeWarp(image,pVec,params,warpHandle); 8 | drawnow; 9 | pause; 10 | end 11 | % cascade regression 12 | layerN = length(Rall); 13 | pVecAll = zeros(layerN+1,params.pDim); 14 | pVecAll(1,:) = pVec'; 15 | for l = 1:layerN 16 | % crop out the warped frame 17 | imageWarp = warpImage(image,pVec,params); 18 | feat = extractFeature(imageWarp,params); 19 | featVec = feat(:); 20 | % apply regression and try to warp back image 21 | dpVec = Rall{l}*[featVec;1]; 22 | % update warp 23 | pVec = composeWarp(pVec,dpVec,params,true); 24 | % visualization 25 | if(visualize) 26 | warpHandle = visualizeWarp(image,pVec,params,warpHandle); 27 | drawnow; 28 | if(params.visualizeTestPause) pause; end 29 | end 30 | pVecAll(l+1,:) = pVec'; 31 | end 32 | imageWarp = warpImage(image,pVec,params); 33 | feat = extractFeature(imageWarp,params); 34 | featVec = feat(:); 35 | -------------------------------------------------------------------------------- /matlab/read1file.m: -------------------------------------------------------------------------------- 1 | % Read 1 image and landmark 2 | function image = read1file(imFname) 3 | 4 | image = imread(imFname); 5 | image = double(rgb2gray(image)); 6 | -------------------------------------------------------------------------------- /matlab/runTest.m: -------------------------------------------------------------------------------- 1 | %% read files 2 | imageAll{1} = imread('simonbaker.png'); 3 | boxGTall{1} = [220,100,460,340]; 4 | % track one image 5 | image = imageAll{1}; 6 | boxGT = boxGTall{1}; 7 | 8 | %% set parameters 9 | params = setParams(imageAll,boxGT); 10 | 11 | %% generate a random warp 12 | while(true) 13 | pVec = genNoiseWarp(params); 14 | % make sure perturbed box doesn't fall out of image 15 | if(checkGoodPerturbedBox(params,pVec,image)) break; end 16 | end 17 | 18 | %% run the regressors 19 | assert(params.pDim = = size(Rall{1},1),'warp dimension mismatch.....'); 20 | [pVecAll,~] = performRegression(params,image,pVec,Rall,true); 21 | -------------------------------------------------------------------------------- /matlab/runTrain.m: -------------------------------------------------------------------------------- 1 | %% read files 2 | imageAll{1} = imread('../images/simonbaker.png'); 3 | % set bounding box ([xmin,ymin,xmax,ymax]) 4 | boxGTall{1} = [220,100,460,340]; 5 | % train on a single image 6 | image = imageAll{1}; 7 | boxGT = boxGTall{1}; 8 | 9 | %% set parameters 10 | params = setParams(imageAll,boxGT); 11 | % precompute the bias image/feature 12 | featGTvec = computeBiasFeature(imageAll,params); 13 | params.featGTvec = featGTvec; 14 | 15 | %% train the regressors 16 | rng('shuffle'); 17 | layerMaxN = 5; 18 | fprintf('Training the regressors...\n'); 19 | if(strcmp(params.regressorType,'LKIC')) 20 | Rall = getLKICregressors(params,layerMaxN); 21 | else 22 | timeTotal = tic; 23 | Rstack = {}; 24 | for layer = 1:layerMaxN 25 | time1layer = tic; 26 | % collect statistics 27 | [trainData,validData] = getStats1layer(imageAll,boxGTall,Rstack,params); 28 | % solve the regressor 29 | R = solveRegressor1layer(params,trainData,validData,layer); 30 | % stack regressors 31 | Rstack = [Rstack;{R}]; 32 | fprintf('----- layer %d done (time=%fsec), total time=%fsec -----\n',layer,toc(time1layer),toc(timeTotal)); 33 | end 34 | Rall = Rstack; 35 | end 36 | -------------------------------------------------------------------------------- /matlab/setParams.m: -------------------------------------------------------------------------------- 1 | % Set the parameter settings 2 | function params = setParams(imageAll,boxGT) 3 | 4 | % type of warp function 5 | % 'T' - translation 6 | % 'S' - similarity 7 | % 'A' - affine 8 | % 'H' - homography 9 | params.warpType = 'A'; 10 | % image size for alignment 11 | params.ImW = 50; 12 | params.ImH = 50; 13 | 14 | % number of examples trained with per layer 15 | params.exampleN = 200; 16 | % number of examples used for validation 17 | params.validationN = max(params.exampleN/10,1); 18 | % scale of perturbations 19 | params.warpScale.pert = 0.06; 20 | params.warpScale.trans = 0.06; 21 | 22 | % set the type of regressor to train/evaluate 23 | % params.regressorType = 'SDM'; 24 | % params.regressorType = 'genLK'; 25 | params.regressorType = 'condLK'; 26 | % params.regressorType = 'LKIC'; 27 | 28 | % options for Conditional LK 29 | % params.condLK_optimize = 'lsqnonlinLM'; 30 | % params.condLK_optimize = 'GaussNewtonGPU'; 31 | params.condLK_optimize = 'LevenbergMarquardtGPU'; 32 | % params.condLK_optimize = 'gradientDescent'; 33 | % params.condLK_optimize = 'LBFGS'; 34 | params.condLK_GNmaxIterN = 30; 35 | params.condLK_LMmaxIterN = 10; 36 | params.condLK_eta = 0.2; 37 | params.condLK_etaDimRate = 0.8; 38 | params.condLK_etaStep = 10; 39 | params.condLK_GDmaxIterN = 100; 40 | params.condLK_LBFGSmaxIterN = 50; 41 | params.condLK_LBFGShistoryN = 20; 42 | 43 | % GPU index if you have one (or more) 44 | params.gpuIndex = 0; 45 | 46 | % type of feature to learn in the LK framework 47 | params.featType = 'pixel'; 48 | % params.featType = 'LBP'; 49 | params.LBP_compareDist = 1; 50 | params.LBP_gaussianSize = 4; 51 | params.LBP_gaussianSigma = 1; 52 | 53 | % fix the SDM regularization factor (usually set to false) 54 | params.fixLambda = false; 55 | params.fixLambdaValue = 1e2; 56 | 57 | % visualize during training/test 58 | params.visualizeTrain = false; 59 | params.visualizeTestPause = true; 60 | 61 | % ------------------the below are automatically set ------------------ 62 | params.imageN = length(imageAll); 63 | params.trainN = params.imageN*params.exampleN; 64 | 65 | switch(params.warpType) 66 | case 'T', params.pDim = 2; % translation 67 | case 'R', params.pDim = 3; % rigid 68 | case 'S', params.pDim = 4; % similarity 69 | case 'A', params.pDim = 6; % affine 70 | case 'H', params.pDim = 8; % homography 71 | otherwise, params.pDim = 0; 72 | end 73 | 74 | params.ImDim = params.ImW*params.ImH; 75 | switch(params.featType) 76 | case 'pixel', 77 | params.featChan = 1; 78 | case 'LBP', 79 | params.featChan = 8; 80 | otherwise, 81 | end 82 | params.featDim = params.ImDim*params.featChan; 83 | 84 | W = params.ImW; 85 | H = params.ImH; 86 | params.boxGT = boxGT; 87 | boxGTcorners = [boxGT(1),boxGT(1),boxGT(3),boxGT(3);... 88 | boxGT(2),boxGT(4),boxGT(4),boxGT(2)]; 89 | ImCorners = [-W/2,-W/2,W/2,W/2; 90 | -H/2,H/2,H/2,-H/2]; 91 | params.Im2imageAffine = affineFit(ImCorners,boxGTcorners); 92 | params.image2ImAffine = affineFit(boxGTcorners,ImCorners); 93 | params.imref2d = imref2d(size(imageAll{1})); 94 | 95 | params.LBP_gaussianKernel = fspecial('gaussian',params.LBP_gaussianSize,params.LBP_gaussianSigma); 96 | -------------------------------------------------------------------------------- /matlab/solveRegressor1layer.m: -------------------------------------------------------------------------------- 1 | % Solve for 1 layer of regressor 2 | function R = solveRegressor1layer(params,trainData,validData,layer) 3 | 4 | % solve for the linear regressor 5 | fprintf('solving for linear regressor...\n'); 6 | timeSolve = tic; 7 | switch(params.regressorType) 8 | case 'SDM', 9 | R = validateModel(trainData,validData,layer,@solve_SDM,params); 10 | case 'genLK', 11 | [R,gOpt] = solve_genLK(params,trainData,layer); 12 | case 'condLK', 13 | [~,gIntm] = solve_genLK(params,trainData,layer); 14 | [R,gOpt] = solve_condLK(params,trainData,layer,gIntm); 15 | otherwise, R = []; 16 | end 17 | % append the bias 18 | R = [R,-R*params.featGTvec]; 19 | fprintf('solve done (time=%fsec)\n',toc(timeSolve)); 20 | 21 | % =================================================== 22 | 23 | % validation for R regularizer (golden ratio search) 24 | function R_opt = validateModel(trainData,validData,layer,solver,params) 25 | 26 | if(params.fixLambda) 27 | % skip validation, use manually determined lambda 28 | fprintf('validation skipped, using lambda=%f\n',params.fixLambdaValue); 29 | R_opt = solver(params,trainData,params.fixLambdaValue); 30 | return; 31 | end 32 | fprintf('validating model.... \n'); 33 | divN = 10; 34 | lambdaMin = -10; 35 | lambdaMax = 10; 36 | ratio = (3-sqrt(5))/2; 37 | % initial logarithm limits on the search 38 | A = lambdaMin; 39 | B = lambdaMax; 40 | [RA,costA] = evaluateCost(10^A,trainData,validData,layer,solver,params); 41 | fprintf('A = %f, costA = %f\n',A,costA); 42 | [RB,costB] = evaluateCost(10^B,trainData,validData,layer,solver,params); 43 | fprintf('B = %f, costB = %f\n',B,costB); 44 | C = A+ratio*(B-A); 45 | [RC,costC] = evaluateCost(10^C,trainData,validData,layer,solver,params); 46 | fprintf('C = %f, costC = %f\n',C,costC); 47 | for div = 1:divN 48 | D = C+ratio*(B-C); 49 | [RD,costD] = evaluateCost(10^D,trainData,validData,layer,solver,params); 50 | if(div>5&&(costD> = costA||costD> = costB)) 51 | fprintf('(objective not U-shape)\n'); 52 | break; 53 | end 54 | if(costC< = costD) 55 | B = A; costB = costA; RB = RA; 56 | A = D; costA = costD; RA = RD; 57 | else 58 | A = C; costA = costC; RA = RC; 59 | C = D; costC = costD; RC = RD; 60 | end 61 | R_opt = RC; 62 | fprintf('div=%d, lambdaOpt=%f, cost=%f (A=%f,B=%f,C=%f,D=%f)\n',div,C,costC,A,B,C,D); 63 | end 64 | 65 | % =================================================== 66 | 67 | % Evaluate cost for validating lambda (R) 68 | function [R,cost] = evaluateCost(lambda,trainData,validData,layer,solver,params) 69 | 70 | R = solver(params,trainData,layer,lambda); 71 | dpAllValid = validData.dpAll; 72 | featDallValid = validData.featDall; 73 | cost = norm(dpAllValid-R*featDallValid)^2; 74 | 75 | -------------------------------------------------------------------------------- /matlab/solve_SDM.m: -------------------------------------------------------------------------------- 1 | % Solve the regressor using SDM 2 | function R = solve_SDM(params,trainData,layer,lambda) 3 | 4 | dpAll = trainData.dpAll; 5 | featDall = trainData.featDall; 6 | R = (dpAll*featDall')/(featDall*featDall'+lambda*eye(params.featDim)); 7 | -------------------------------------------------------------------------------- /matlab/solve_condLK.m: -------------------------------------------------------------------------------- 1 | % Solve the regressor using Conditional Lucas-Kanade 2 | function [R,gOpt] = solve_condLK(params,trainData,layer,gIntm) 3 | 4 | dpAll = trainData.dpAll; 5 | featDall = trainData.featDall; 6 | P = params.pDim; 7 | D = params.ImDim; 8 | K = params.featChan; 9 | if(strcmp(params.condLK_optimize,'lsqnonlinLM')) 10 | objFuncLMH = @(g) objFuncLM(g,params,dpAll,featDall); 11 | opts = optimoptions(@lsqnonlin,'algorithm','levenberg-marquardt',... 12 | 'display','iter-detailed',... 13 | 'maxiter',params.condLK_LMmaxIterN,... 14 | 'jacobian','on'); 15 | gOpt = lsqnonlin(objFuncLMH,gIntm,[],[],opts); 16 | elseif(strcmp(params.condLK_optimize,'GaussNewtonGPU')) 17 | gpuDevice(params.gpuIndex); 18 | g = gIntm; 19 | f = compute_f(params,g,dpAll,featDall); 20 | fprintf('layer %d init, obj = %f\n',layer,f); 21 | for it = 1:params.condLK_GNmaxIterN 22 | [f,dfdg] = objFuncLM(g,params,dpAll,featDall); 23 | bGPU = gpuArray(f); 24 | AGPU = -gpuArray(dfdg); 25 | dgtempGPU = AGPU\bGPU; 26 | dgOpt = gather(dgtempGPU); 27 | cost = compute_f(params,g+dgOpt,dpAll,featDall); 28 | fprintf('it = %d/%d, obj = %f\n',it,params.condLK_GNmaxIterN,cost); 29 | g = g+dgOpt; 30 | end 31 | gOpt = g; 32 | elseif(strcmp(params.condLK_optimize,'LevenbergMarquardtGPU')) 33 | gpuDevice(params.gpuIndex); 34 | diagIdx = [0:2*D*K-1]*2*D*K+[0:2*D*K-1]+1; 35 | divN = 10; 36 | lambdaMin = -5; 37 | lambdaMax = 5; 38 | ratio = (3-sqrt(5))/2; 39 | g = gIntm; 40 | f = compute_f(params,g,dpAll,featDall); 41 | fprintf('layer %d init, obj = %f\n',layer,f); 42 | for it = 1:params.condLK_LMmaxIterN 43 | [f,dfdg] = objFuncLM(g,params,dpAll,featDall); 44 | % preload matrices in GPU 45 | bGPU = gpuArray(f); 46 | AGPU = -gpuArray(dfdg); 47 | AtAGPU = AGPU'*AGPU; 48 | AtbGPU = AGPU'*bGPU; 49 | diagAtAGPU = AtAGPU(diagIdx); 50 | % find best damping factor (golden ratio search) 51 | A = lambdaMin; 52 | B = lambdaMax; 53 | AtAGPU(diagIdx) = (1+10^A)*diagAtAGPU; 54 | dgtempGPU = AtAGPU\AtbGPU; dgA = gather(dgtempGPU); 55 | costA = compute_f(params,g+dgA,dpAll,featDall); 56 | AtAGPU(diagIdx) = (1+10^B)*diagAtAGPU; 57 | dgtempGPU = AtAGPU\AtbGPU; dgB = gather(dgtempGPU); 58 | costB = compute_f(params,g+dgB,dpAll,featDall); 59 | C = A+ratio*(B-A); 60 | AtAGPU(diagIdx) = (1+10^C)*diagAtAGPU; 61 | dgtempGPU = AtAGPU\AtbGPU; dgC = gather(dgtempGPU); 62 | costC = compute_f(params,g+dgC,dpAll,featDall); 63 | for div = 1:divN 64 | D = C+ratio*(B-C); 65 | AtAGPU(diagIdx) = (1+10^D)*diagAtAGPU; 66 | dgtempGPU = AtAGPU\AtbGPU; dgD = gather(dgtempGPU); 67 | costD = compute_f(params,g+dgD,dpAll,featDall); 68 | if(div>5&&(costD> = costA||costD> = costB)) 69 | break; 70 | end 71 | if(costC< = costD) 72 | B = A; costB = costA; dgB = dgA; 73 | A = D; costA = costD; dgA = dgD; 74 | else 75 | A = C; costA = costC; dgA = dgC; 76 | C = D; costC = costD; dgC = dgD; 77 | end 78 | dgOpt = dgC; 79 | end 80 | fprintf('it = %d/%d, lambda = %f, obj = %f\n',it,params.condLK_LMmaxIterN,C,costC); 81 | g = g+dgOpt; 82 | end 83 | gOpt = g; 84 | elseif(strcmp(params.condLK_optimize,'gradientDescent')) 85 | eta = params.condLK_eta; 86 | etaDimRate = params.condLK_etaDimRate; 87 | etaStep = params.condLK_etaStep; 88 | g = gIntm; 89 | f = compute_f(params,g,dpAll,featDall); 90 | fprintf('init, eta = %f, obj = %f\n',eta,f); 91 | for it = 1:params.condLK_GDmaxIterN 92 | dfdg = compute_dfdg(params,g,dpAll,featDall); 93 | g = g-eta*dfdg; 94 | f = compute_f(params,g,dpAll,featDall); 95 | fprintf('it = %d/%d, eta = %f, obj = %f\n',it,params.condLK_GDmaxIterN,eta,f); 96 | if(mod(it,etaStep) = = 0) eta = eta*etaDimRate; end 97 | end 98 | gOpt = g; 99 | elseif(strcmp(params.condLK_optimize,'LBFGS')) 100 | addpath(genpath('../minFunc_2012')); 101 | options.Method = 'lbfgs'; 102 | options.maxFunEvals = params.condLK_LBFGSmaxIterN; 103 | options.Corr = params.condLK_LBFGShistoryN; 104 | options.LS_interp = 1; 105 | options.Damped = 1; 106 | objFuncMinFuncH = @(g) objFuncMinFunc(params,g,dpAll,featDall); 107 | f = compute_f(params,gIntm,dpAll,featDall); 108 | fprintf('init, obj = %f\n',f); 109 | gOpt = minFunc(objFuncMinFuncH,gIntm,options); 110 | end 111 | % form the final regressor 112 | R = computeLKregressor(params,gOpt); 113 | 114 | % =================================================== 115 | 116 | % Compute objective function 117 | function [f,dfdg] = objFuncLM(g,params,dpAll,featDall) 118 | 119 | addpath('../mtimesx_20110223/'); 120 | P = params.pDim; 121 | D = params.ImDim; 122 | K = params.featChan; 123 | N = size(dpAll,2); 124 | R = computeLKregressor(params,g); 125 | F = dpAll-R*featDall; 126 | f = F(:); 127 | dFdgReshape = zeros(P,N,2*D,K); 128 | parfor k = 1:K 129 | dRdg1k = compute_dRdg1k(g,k,params); 130 | dFdgReshape(:,:,:,k) = -mtimesx(dRdg1k,featDall); 131 | end 132 | dfdg = reshape(dFdgReshape,[P*N,2*D*K]); 133 | 134 | % =================================================== 135 | 136 | % Compute objective function 137 | function [f,dfdg] = objFuncMinFunc(params,g,dpAll,featDall) 138 | f = compute_f(params,g,dpAll,featDall); 139 | dfdg = compute_dfdg(params,g,dpAll,featDall); 140 | 141 | % =================================================== 142 | 143 | % Compute objective function 144 | function f = compute_f(params,g,dpAll,featDall) 145 | N = params.trainN; 146 | R = computeLKregressor(params,g); 147 | f = norm(dpAll-R*featDall,'fro')^2/N; 148 | % Compute gradient of objective 149 | function dfdg = compute_dfdg(params,g,dpAll,featDall) 150 | P = params.pDim; 151 | D = params.ImDim; 152 | K = params.featChan; 153 | N = params.trainN; 154 | R = computeLKregressor(params,g); 155 | dfdR = -2*(dpAll-R*featDall)*featDall'; 156 | % dRdg = compute_dRdg(g,params); 157 | % dvecRdg = reshape(dRdg,[P*D*K,2*D*K]); 158 | % dfdg = dvecRdg'*dfdR(:)/N; 159 | dfdvecR = dfdR(:); 160 | dfdgReshape = zeros(2*D,K); 161 | parfor k = 1:K 162 | dRdg1k = compute_dRdg1k(g,k,params); 163 | dvecRdg1k = reshape(dRdg1k,[P*D*K,2*D]); 164 | dfdg1k = dvecRdg1k'*dfdvecR/N; 165 | dfdgReshape(:,k) = dfdg1k; 166 | end 167 | dfdgReshapeX = dfdgReshape(1:D,:); 168 | dfdgReshapeY = dfdgReshape(D+1:2*D,:); 169 | dfdg = [dfdgReshapeX(:);dfdgReshapeY(:)]; 170 | 171 | -------------------------------------------------------------------------------- /matlab/solve_genLK.m: -------------------------------------------------------------------------------- 1 | % Solve the regressor using Generative Lucas-Kanade 2 | function [R,gOpt] = solve_genLK(params,trainData,layer) 3 | 4 | dpAll = trainData.dpAll; 5 | featDall = trainData.featDall; 6 | D = params.ImDim; 7 | K = params.featChan; 8 | % precompute vectors/matrices 9 | dxdp = compute_dxdp(params); 10 | dxAll = dxdp*dpAll; 11 | gOpt = zeros(2*D*K,1); 12 | for d = 1:D 13 | b = featDall(D*[0:K-1]+d,:); 14 | A = dxAll([d,d+D],:); 15 | % solve the small linear system 16 | gLs = b/A; 17 | gOpt(D*[0:2*K-1]+d) = gLs(:); 18 | end 19 | % form the final regressor 20 | R = computeLKregressor(params,gOpt); 21 | -------------------------------------------------------------------------------- /matlab/visualizeGradients.m: -------------------------------------------------------------------------------- 1 | % Transform R back to gradients and visualize 2 | function visualizeGradients(R,range) 3 | 4 | H = 50; 5 | W = 50; 6 | Gdxdp = pinv(R(:,1:end-1)); 7 | p = size(R,1); 8 | switch(p) 9 | case 2, % translation 10 | gx = Gdxdp(:,1); 11 | gy = Gdxdp(:,2); 12 | case 6, % affine 13 | gx = Gdxdp(:,5); 14 | gy = Gdxdp(:,6); 15 | case 8, % homography 16 | gx = Gdxdp(:,3); 17 | gy = Gdxdp(:,6); 18 | end 19 | gImgX = reshape(gx,H,W,[]); 20 | gImgY = reshape(gy,H,W,[]); 21 | gImgXstack = permute(gImgX,[1,2,4,3]); 22 | gImgYstack = permute(gImgY,[1,2,4,3]); 23 | addpath('..'); 24 | warning('off'); 25 | figure(5),imdisp(gImgXstack,[-range,range],'border',0.03); 26 | figure(6),imdisp(gImgYstack,[-range,range],'border',0.03); 27 | warning('on'); 28 | 29 | 30 | -------------------------------------------------------------------------------- /matlab/visualizeWarp.m: -------------------------------------------------------------------------------- 1 | % Visualize the image with the warped box and ground truth 2 | function warpHandle = visualizeWarp(image,pVec,params,warpHandle) 3 | 4 | % warp the box 5 | pMtrx = warpVec2Mtrx(params,pVec); 6 | W = params.ImW; 7 | H = params.ImH; 8 | ImBox = [-W/2,-W/2,W/2,W/2,-W/2; 9 | -H/2,H/2,H/2,-H/2,-H/2]; 10 | warpImBox = pMtrx*[ImBox;[1,1,1,1,1]]; 11 | warpImBox(1,:) = warpImBox(1,:)./warpImBox(3,:); 12 | warpImBox(2,:) = warpImBox(2,:)./warpImBox(3,:); 13 | warpImBox(3,:) = 1; 14 | warpImageBox = params.Im2imageAffine*warpImBox; 15 | warpImageBox(3,:) = []; 16 | imageBox = params.Im2imageAffine*[ImBox;[1,1,1,1,1]]; 17 | imageBox(3,:) = []; 18 | % plot the box 19 | if(isempty(warpHandle)) 20 | % create new plot 21 | figure(1),imshow(uint8(image)); hold on; 22 | plot(imageBox(1,:),imageBox(2,:),'color',[1,0.3,0.3],'linewidth',2); 23 | warpHandle = plot(warpImageBox(1,:),warpImageBox(2,:),'color',[0.3,1,0.3],'linewidth',2); 24 | else 25 | % just update the warped box 26 | set(warpHandle,'XData',warpImageBox(1,:)); 27 | set(warpHandle,'YData',warpImageBox(2,:)); 28 | end 29 | -------------------------------------------------------------------------------- /matlab/warpImage.m: -------------------------------------------------------------------------------- 1 | % Retrieve the current warped image 2 | function imageWarp = warpImage(image,pVec,params) 3 | 4 | image = double(rgb2gray(image)); 5 | pMtrx = warpVec2Mtrx(params,pVec); 6 | % map to Im coordinate, perform warp, then map back to image coordinate 7 | % forward warping the box --> inverse warping the image 8 | transMtrx = params.Im2imageAffine... 9 | *(pMtrx... 10 | \params.image2ImAffine); 11 | % apply warp to image 12 | tform = projective2d(transMtrx'); 13 | imageWarp = imwarp(image,tform,'cubic','outputview',params.imref2d); 14 | 15 | -------------------------------------------------------------------------------- /matlab/warpMtrx2Vec.m: -------------------------------------------------------------------------------- 1 | % Get the warp matrix from the warp parameter vector 2 | function warpVec = warpMtrx2Vec(params,warpMtrx) 3 | 4 | switch(params.warpType) 5 | case 'T', % translation 6 | tx = warpMtrx(1,3); 7 | ty = warpMtrx(2,3); 8 | warpVec = [tx,ty]'; 9 | case 'R', % rigid 10 | dr = asin(warpMtrx(2,1)); % assuming dr is within +-pi/2 11 | tx = warpMtrx(1,3); 12 | ty = warpMtrx(2,3); 13 | warpVec = [dr,tx,ty]'; 14 | case 'S', % similarity 15 | pc = warpMtrx(1,1)-1; 16 | ps = warpMtrx(2,1); 17 | tx = warpMtrx(1,3); 18 | ty = warpMtrx(2,3); 19 | warpVec = [pc,ps,tx,ty]'; 20 | case 'A', % affine 21 | p1 = warpMtrx(1,1)-1; 22 | p2 = warpMtrx(1,2); 23 | p3 = warpMtrx(2,1); 24 | p4 = warpMtrx(2,2)-1; 25 | p5 = warpMtrx(1,3); 26 | p6 = warpMtrx(2,3); 27 | warpVec = [p1,p2,p3,p4,p5,p6]'; 28 | case 'H', % homography 29 | p1 = warpMtrx(1,1)-1; 30 | p2 = warpMtrx(1,2); 31 | p3 = warpMtrx(1,3); 32 | p4 = warpMtrx(2,1); 33 | p5 = warpMtrx(2,2)-1; 34 | p6 = warpMtrx(2,3); 35 | p7 = warpMtrx(3,1); 36 | p8 = warpMtrx(3,2); 37 | warpVec = [p1,p2,p3,p4,p5,p6,p7,p8]'; 38 | otherwise 39 | warpVec = []; 40 | end 41 | -------------------------------------------------------------------------------- /matlab/warpVec2Mtrx.m: -------------------------------------------------------------------------------- 1 | % Get the warp parameter vector from the warp matrix 2 | function warpMtrx = warpVec2Mtrx(params,warpVec) 3 | 4 | switch(params.warpType) 5 | case 'T', % translation 6 | tx = warpVec(1); 7 | ty = warpVec(2); 8 | warpMtrx = [1,0,tx;... 9 | 0,1,ty;... 10 | 0,0, 1]; 11 | case 'R', % rigid 12 | dr = warpVec(1); 13 | tx = warpVec(2); 14 | ty = warpVec(3); 15 | warpMtrx = [cos(dr),-sin(dr),tx;... 16 | sin(dr), cos(dr),ty;... 17 | 0, 0, 1]; 18 | case 'S', % similarity 19 | pc = warpVec(1); 20 | ps = warpVec(2); 21 | tx = warpVec(3); 22 | ty = warpVec(4); 23 | warpMtrx = [1+pc, -ps,tx;... 24 | ps,1+pc,ty;... 25 | 0, 0, 1]; 26 | case 'A', % affine 27 | p1 = warpVec(1); 28 | p2 = warpVec(2); 29 | p3 = warpVec(3); 30 | p4 = warpVec(4); 31 | p5 = warpVec(5); 32 | p6 = warpVec(6); 33 | warpMtrx = [1+p1, p2,p5;... 34 | p3,1+p4,p6;... 35 | 0, 0, 1]; 36 | case 'H', % homography 37 | p1 = warpVec(1); 38 | p2 = warpVec(2); 39 | p3 = warpVec(3); 40 | p4 = warpVec(4); 41 | p5 = warpVec(5); 42 | p6 = warpVec(6); 43 | p7 = warpVec(7); 44 | p8 = warpVec(8); 45 | warpMtrx = [1+p1, p2,p3;... 46 | p4,1+p5,p6;... 47 | p7, p8, 1]; 48 | otherwise 49 | warpMtrx = []; 50 | end 51 | -------------------------------------------------------------------------------- /mtimesx_20110223/license.txt: -------------------------------------------------------------------------------- 1 | Copyright (c) 2011, James Tursa 2 | All rights reserved. 3 | 4 | Redistribution and use in source and binary forms, with or without 5 | modification, are permitted provided that the following conditions are 6 | met: 7 | 8 | * Redistributions of source code must retain the above copyright 9 | notice, this list of conditions and the following disclaimer. 10 | * Redistributions in binary form must reproduce the above copyright 11 | notice, this list of conditions and the following disclaimer in 12 | the documentation and/or other materials provided with the distribution 13 | 14 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 15 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 16 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 17 | ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 18 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 19 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 20 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 21 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 22 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 23 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 24 | POSSIBILITY OF SUCH DAMAGE. 25 | -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx.c: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenhsuanlin/conditional-LK/ecd86d3c00e563cbe5e658fc268628c4acbff5c3/mtimesx_20110223/mtimesx.c -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx.m: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenhsuanlin/conditional-LK/ecd86d3c00e563cbe5e658fc268628c4acbff5c3/mtimesx_20110223/mtimesx.m -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx.mexa64: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenhsuanlin/conditional-LK/ecd86d3c00e563cbe5e658fc268628c4acbff5c3/mtimesx_20110223/mtimesx.mexa64 -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx_20110223.pdf: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/chenhsuanlin/conditional-LK/ecd86d3c00e563cbe5e658fc268628c4acbff5c3/mtimesx_20110223/mtimesx_20110223.pdf -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx_build.m: -------------------------------------------------------------------------------- 1 | % mtimesx_build compiles mtimesx.c with BLAS libraries 2 | %****************************************************************************** 3 | % 4 | % MATLAB (R) is a trademark of The Mathworks (R) Corporation 5 | % 6 | % Function: mtimesx_build 7 | % Filename: mtimesx_build.m 8 | % Programmer: James Tursa 9 | % Version: 1.40 10 | % Date: October 4, 2010 11 | % Copyright: (c) 2009, 2010 by James Tursa, All Rights Reserved 12 | % 13 | % This code uses the BSD License: 14 | % 15 | % Redistribution and use in source and binary forms, with or without 16 | % modification, are permitted provided that the following conditions are 17 | % met: 18 | % 19 | % * Redistributions of source code must retain the above copyright 20 | % notice, this list of conditions and the following disclaimer. 21 | % * Redistributions in binary form must reproduce the above copyright 22 | % notice, this list of conditions and the following disclaimer in 23 | % the documentation and/or other materials provided with the distribution 24 | % 25 | % THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26 | % AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 | % IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 | % ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29 | % LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 | % CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 | % SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 | % INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 | % CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 | % ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 | % POSSIBILITY OF SUCH DAMAGE. 36 | % 37 | %-- 38 | % 39 | % mtimesx_build compiles mtimesx.c and mtimesx_RealTimesReal.c with the BLAS 40 | % libraries libmwblas.lib (if present) or libmwlapack.lib (if libmwblas.lib 41 | % is not present). This function basically works as follows: 42 | % 43 | % - Opens the current mexopts.bat file in the directory [prefdir], and 44 | % checks to make sure that the compiler selected is cl or lcc. If it 45 | % is not, then a warning is issued and the compilation continues with 46 | % the assumption that the microsoft BLAS libraries will work. 47 | % 48 | % - Looks for the file libmwblas.lib or libmwlapack.lib files in the 49 | % appropriate directory: [matlabroot '\extern\lib\win32\microsoft'] 50 | % or [matlabroot '\extern\lib\win32\lcc'] 51 | % or [matlabroot '\extern\lib\win64\microsoft'] 52 | % or [matlabroot '\extern\lib\win64\lcc'] 53 | % 54 | % - Changes directory to the directory of the file mtimesx.m. 55 | % 56 | % - Compiles mtimesx.c (which includes mtimesx_RealTimesReal.c) along with 57 | % either libmwblas.lib or libmwlapack.lib depending on the version of 58 | % MATLAB. The resulting exedcutable mex file is placed in the same 59 | % directory as the source code. The files mtimesx.m, mtimesx.c, and 60 | % mtimesx_RealTimesReal.c must all be in the same directory. 61 | % 62 | % - Changes the directory back to the original directory. 63 | % 64 | % Change Log: 65 | % 2009/Sep/27 --> 1.00, Initial Release 66 | % 2010/Feb/15 --> 1.10, Fixed largearrardims typo to largeArrayDims 67 | % 2010/Oct/04 --> 1.40, Updated support for OpenMP compiling 68 | % 69 | %************************************************************************** 70 | 71 | function mtimesx_build(x) 72 | disp(' '); 73 | disp('... Build routine for mtimesx'); 74 | 75 | TRUE = 1; 76 | FALSE = 0; 77 | 78 | %\ 79 | % Check for number of inputs & outputs 80 | %/ 81 | 82 | noopenmp = FALSE; 83 | if( nargin == 1 ) 84 | if( isequal(upper(x),'NOOPENMP') ) 85 | noopenmp = TRUE; 86 | else 87 | error('Invalid input.'); 88 | end 89 | elseif( nargin ~= 0 ) 90 | error('Too many inputs. Expected none.'); 91 | end 92 | if( nargout ~= 0 ) 93 | error('Too many outputs. Expected none.'); 94 | end 95 | 96 | %\ 97 | % Check for non-PC 98 | %/ 99 | 100 | disp('... Checking for PC'); 101 | try 102 | % ispc does not appear in MATLAB 5.3 103 | pc = ispc ; 104 | catch 105 | % if ispc fails, assume we are on a Windows PC if it's not unix 106 | pc = ~isunix ; 107 | end 108 | 109 | if( ~pc ) 110 | disp('Non-PC auto build is not currently supported. You will have to'); 111 | disp('manually compile the mex routine. E.g., as follows:'); 112 | disp(' '); 113 | disp('>> blas_lib = ''the_actual_path_and_name_of_your_systems_BLAS_library'''); 114 | disp('>> mex(''-DDEFINEUNIX'',''mtimesx.c'',blas_lib)'); 115 | disp(' '); 116 | disp('or'); 117 | disp(' '); 118 | disp('>> mex(''-DDEFINEUNIX'',''-largeArrayDims'',''mtimesx.c'',blas_lib)'); 119 | disp(' '); 120 | error('Unable to compile mtimesx.c'); 121 | end 122 | 123 | %\ 124 | % Check to see that mtimesx.c source code is present 125 | %/ 126 | 127 | disp('... Finding path of mtimesx C source code files'); 128 | try 129 | mname = mfilename('fullpath'); 130 | catch 131 | mname = mfilename; 132 | end 133 | cname = [mname(1:end-6) '.c']; 134 | if( isempty(dir(cname)) ) 135 | disp('Cannot find the file mtimesx.c in the same directory as the'); 136 | disp('file mtimesx_build.m. Please ensure that they are in the same'); 137 | disp('directory and try again. The following file was not found:'); 138 | disp(' '); 139 | disp(cname); 140 | disp(' '); 141 | error('Unable to compile mtimesx.c'); 142 | end 143 | disp(['... Found file mtimesx.c in ' cname]); 144 | 145 | %\ 146 | % Check to see that mtimesx_RealTimesReal.c source code is present 147 | %/ 148 | 149 | rname = [mname(1:end-13) 'mtimesx_RealTimesReal.c']; 150 | if( isempty(dir(rname)) ) 151 | disp('Cannot find the file mtimesx_RealTimesReal.c in the same'); 152 | disp('directory as the file mtimesx_build.m. Please ensure that'); 153 | disp('they are in the same directory and try again. The'); 154 | disp('following file was not found:'); 155 | disp(' '); 156 | disp(rname); 157 | disp(' '); 158 | error('Unable to compile mtimesx.c'); 159 | end 160 | disp(['... Found file mtimesx_RealTimesReal.c in ' rname]); 161 | 162 | %\ 163 | % Open the current mexopts.bat file 164 | %/ 165 | 166 | mexopts = [prefdir '\mexopts.bat']; 167 | fid = fopen(mexopts); 168 | if( fid == -1 ) 169 | error('A C/C++ compiler has not been selected with mex -setup'); 170 | end 171 | disp(['... Opened the mexopts.bat file in ' mexopts]); 172 | disp('... Reading the mexopts.bat file to find the compiler and options used.'); 173 | 174 | %\ 175 | % Check for the correct compiler selected. 176 | %/ 177 | 178 | ok_cl = FALSE; 179 | ok_lcc = FALSE; 180 | omp_option = ''; 181 | compiler = '(unknown)'; 182 | compilername = ''; 183 | while( TRUE ) 184 | tline = fgets(fid); 185 | if( isequal(tline,-1) ) 186 | break; 187 | else 188 | if( isempty(compilername) ) 189 | y = findstr(tline,'OPTS.BAT'); 190 | if( ~isempty(y) ) 191 | x = findstr(tline,'rem '); 192 | if( ~isempty(x) ) 193 | compilername = tline(x+4:y-1); 194 | end 195 | end 196 | end 197 | x = findstr(tline,'COMPILER=lcc'); 198 | if( ~isempty(x) ) 199 | ok_lcc = TRUE; 200 | libdir = 'lcc'; 201 | compiler = 'LCC'; 202 | disp(['... ' compiler ' is the selected compiler']); 203 | break; 204 | end 205 | x = findstr(tline,'COMPILER=cl'); 206 | if( ~isempty(x) ) 207 | ok_cl = TRUE; 208 | libdir = 'microsoft'; 209 | compiler = ['Microsoft_' compilername '_cl']; 210 | omp_option = ' /openmp'; 211 | disp(['... ' compiler ' is the selected compiler']); 212 | break; 213 | end 214 | x = findstr(tline,'COMPILER=bcc32'); 215 | if( ~isempty(x) ) 216 | ok_cl = TRUE; 217 | libdir = 'microsoft'; 218 | compiler = ['Borland_' compilername '_bcc32']; 219 | disp(['... ' compiler ' is the selected compiler']); 220 | disp('... Assuming that Borland will link with Microsoft libraries'); 221 | break; 222 | end 223 | x = findstr(tline,'COMPILER=icl'); 224 | if( ~isempty(x) ) 225 | ok_cl = TRUE; 226 | if( pc ) 227 | omp_option = ' -Qopenmp'; 228 | else 229 | omp_option = ' -openmp'; 230 | end 231 | libdir = 'microsoft'; 232 | compiler = ['Intel_' compilername '_icl']; 233 | disp(['... ' compiler ' is the selected compiler']); 234 | disp('... Assuming that Intel will link with Microsoft libraries'); 235 | break; 236 | end 237 | x = findstr(tline,'COMPILER=wc1386'); 238 | if( ~isempty(x) ) 239 | ok_cl = TRUE; 240 | libdir = 'microsoft'; 241 | compiler = ['Watcom_' compilername '_wc1386']; 242 | disp(['... ' compiler ' is the selected compiler']); 243 | disp('... Assuming that Watcom will link with Microsoft libraries'); 244 | break; 245 | end 246 | x = findstr(tline,'COMPILER=gcc'); 247 | if( ~isempty(x) ) 248 | ok_cl = TRUE; 249 | libdir = 'microsoft'; 250 | omp_option = ' -fopenmp'; 251 | compiler = 'GCC'; 252 | disp(['... ' compiler ' is the selected compiler']); 253 | disp('... Assuming that GCC will link with Microsoft libraries'); 254 | break; 255 | end 256 | end 257 | end 258 | fclose(fid); 259 | 260 | %\ 261 | % MS Visual C/C++ or lcc compiler has not been selected 262 | %/ 263 | 264 | if( ~(ok_cl | ok_lcc) ) 265 | warning('... Supported C/C++ compiler has not been selected with mex -setup'); 266 | warning('... Assuming that Selected Compiler will link with Microsoft libraries'); 267 | warning('... Continuing at risk ...'); 268 | libdir = 'microsoft'; 269 | end 270 | 271 | %\ 272 | % If an OpenMP supported compiler is potentially present, make sure that the 273 | % necessary compile option is present in the mexopts.bat file on the COMPFLAGS 274 | % line. If necessary, build a new mexopts.bat file with the correct option 275 | % added to the COMPFLAGS line. 276 | %/ 277 | 278 | while( TRUE ) 279 | ok_openmp = FALSE; 280 | ok_compflags = FALSE; 281 | xname = ''; 282 | if( isempty(omp_option) ) 283 | disp('... OpenMP compiler not detected ... you may want to check this website:'); 284 | disp(' http://openmp.org/wp/openmp-compilers/'); 285 | elseif( noopenmp ) 286 | disp(['... OpenMP compiler potentially detected, but not checking for ''' omp_option ''' compile option']); 287 | else 288 | disp('... OpenMP compiler potentially detected'); 289 | disp(['... Checking to see that the ''' omp_option ''' compile option is present']); 290 | fid = fopen(mexopts); 291 | while( TRUE ) 292 | tline = fgets(fid); 293 | if( isequal(tline,-1) ) 294 | break; 295 | else 296 | x = findstr(tline,'set COMPFLAGS'); 297 | if( ~isempty(x) ) 298 | ok_compflags = TRUE; 299 | x = findstr(tline,omp_option); 300 | if( ~isempty(x) ) 301 | ok_openmp = TRUE; 302 | end 303 | break; 304 | end 305 | end 306 | end 307 | fclose(fid); 308 | if( ~ok_compflags ) 309 | warning(['... COMPFLAGS line not found ... ''' omp_option ''' will not be added.']); 310 | elseif( ~ok_openmp ) 311 | disp(['... The ''' omp_option ''' compile option is not present ... adding it']); 312 | xname = [mname(1:end-6) '_mexopts.bat']; 313 | disp(['... Creating custom options file ' xname ' with the ''' omp_option ''' option added.']); 314 | fid = fopen(mexopts); 315 | fidx = fopen(xname,'w'); 316 | if( fidx == -1 ) 317 | xname = ''; 318 | warning(['... Unable to create custom mexopts.bat file ... ''' omp_option ''' will not be added']); 319 | else 320 | while( TRUE ) 321 | tline = fgets(fid); 322 | if( isequal(tline,-1) ) 323 | break; 324 | else 325 | x = findstr(tline,'set COMPFLAGS'); 326 | if( ~isempty(x) ) 327 | n = numel(tline); 328 | e = n; 329 | while( tline(e) < 32 ) 330 | e = e - 1; 331 | end 332 | tline = [tline(1:e) omp_option tline(e+1:n)]; 333 | end 334 | fwrite(fidx,tline); 335 | end 336 | end 337 | fclose(fidx); 338 | end 339 | fclose(fid); 340 | end 341 | end 342 | 343 | %\ 344 | % Construct full file name of libmwblas.lib and libmwlapack.lib. Note that 345 | % not all versions have both files. Earlier versions only had the lapack 346 | % file, which contained both blas and lapack routines. 347 | %/ 348 | 349 | comp = computer; 350 | mext = mexext; 351 | lc = length(comp); 352 | lm = length(mext); 353 | cbits = comp(max(1:lc-1):lc); 354 | mbits = mext(max(1:lm-1):lm); 355 | if( isequal(cbits,'64') | isequal(mbits,'64') ) 356 | compdir = 'win64'; 357 | largearraydims = '-largeArrayDims'; 358 | else 359 | compdir = 'win32'; 360 | largearraydims = ''; 361 | end 362 | 363 | lib_blas = [matlabroot '\extern\lib\' compdir '\' libdir '\libmwblas.lib']; 364 | d = dir(lib_blas); 365 | if( isempty(d) ) 366 | disp('... BLAS library file not found, so linking with the LAPACK library'); 367 | lib_blas = [matlabroot '\extern\lib\' compdir '\' libdir '\libmwlapack.lib']; 368 | end 369 | disp(['... Using BLAS library lib_blas = ''' lib_blas '''']); 370 | 371 | %\ 372 | % Save old directory and change to source code directory 373 | %/ 374 | 375 | cdold = cd; 376 | if( length(mname) > 13 ) 377 | cd(mname(1:end-13)); 378 | end 379 | 380 | %\ 381 | % Do the compile 382 | %/ 383 | 384 | disp('... Now attempting to compile ...'); 385 | disp(' '); 386 | try 387 | if( isunix ) 388 | if( isempty(largearraydims) ) 389 | if( isempty(xname) ) 390 | disp(['mex(''-DDEFINEUNIX'',''' cname ''',lib_blas,''-DCOMPILER=' compiler ''')']); 391 | disp(' '); 392 | mex('-DDEFINEUNIX',cname,lib_blas,['-DCOMPILER=' compiler]); 393 | else 394 | disp(['mex(''-f'',''' xname ''',''-DDEFINEUNIX'',''' cname ''',lib_blas,''-DCOMPILER=' compiler ''')']); 395 | disp(' '); 396 | mex('-f',xname,'-DDEFINEUNIX',cname,lib_blas,['-DCOMPILER=' compiler]); 397 | end 398 | else 399 | if( isempty(xname) ) 400 | disp(['mex(''-DDEFINEUNIX'',''' cname ''',''' largearraydims ''',lib_blas,''-DCOMPILER=' compiler ''')']); 401 | disp(' '); 402 | mex('-DDEFINEUNIX',largearraydims,cname,lib_blas,['-DCOMPILER=' compiler]); 403 | else 404 | disp(['mex(''-f'',''' xname ''',''-DDEFINEUNIX'',''' cname ''',''' largearraydims ''',lib_blas,''-DCOMPILER=' compiler ''')']); 405 | disp(' '); 406 | mex('-f',xname,'-DDEFINEUNIX',largearraydims,cname,lib_blas,['-DCOMPILER=' compiler]); 407 | end 408 | end 409 | else 410 | if( isempty(largearraydims) ) 411 | if( isempty(xname) ) 412 | disp(['mex(''' cname ''',lib_blas,''-DCOMPILER=' compiler ''')']); 413 | disp(' '); 414 | mex(cname,lib_blas,['-DCOMPILER=' compiler]); 415 | else 416 | disp(['mex(''-f'',''' xname ''',''' cname ''',lib_blas,''-DCOMPILER=' compiler ''')']); 417 | disp(' '); 418 | mex('-f',xname,cname,lib_blas,['-DCOMPILER=' compiler]); 419 | end 420 | else 421 | if( isempty(xname) ) 422 | disp(['mex(''' cname ''',''' largearraydims ''',lib_blas,''-DCOMPILER=' compiler ''')']); 423 | disp(' '); 424 | mex(cname,largearraydims,lib_blas,['-DCOMPILER=' compiler]); 425 | else 426 | disp(['mex(''-f'',''' xname ''',''' cname ''',''' largearraydims ''',lib_blas,''-DCOMPILER=' compiler ''')']); 427 | disp(' '); 428 | mex('-f',xname,cname,largearraydims,lib_blas,['-DCOMPILER=' compiler]); 429 | end 430 | end 431 | end 432 | disp('... mex mtimesx.c build completed ... you may now use mtimesx.'); 433 | disp(' '); 434 | mtimesx; 435 | break; 436 | catch 437 | if( noopenmp ) 438 | cd(cdold); 439 | disp(' '); 440 | disp('... Well, *that* didn''t work either!'); 441 | disp(' '); 442 | disp('The mex command failed. This may be because you have already run'); 443 | disp('mex -setup and selected a non-C compiler, such as Fortran. If this'); 444 | disp('is the case, then rerun mex -setup and select a C/C++ compiler.'); 445 | disp(' '); 446 | error('Unable to compile mtimesx.c'); 447 | else 448 | disp(' '); 449 | disp('... Well, *that* didn''t work ...'); 450 | disp(' '); 451 | if( isequal(omp_option,' /openmp') ) 452 | disp('This may be because an OpenMP compile option was added that the'); 453 | disp('compiler did not like. For example, the Standard versions of the'); 454 | disp('Microsoft C/C++ compilers do not support OpenMP, only the'); 455 | disp('Professional versions do. Attempting to compile again but this'); 456 | disp(['time will not add the ''' omp_option ''' option.']) 457 | else 458 | disp('This may be because an OpenMP compile option was added that the'); 459 | disp('compiler did not like. Attempting to compile again, but this time'); 460 | disp(['will not add the ''' omp_option ''' option.']) 461 | end 462 | disp(' '); 463 | noopenmp = TRUE; 464 | end 465 | end 466 | end 467 | 468 | %\ 469 | % Restore old directory 470 | %/ 471 | 472 | cd(cdold); 473 | 474 | return 475 | end 476 | -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx_sparse.m: -------------------------------------------------------------------------------- 1 | % mtimesx_sparse does sparse matrix multiply of two inputs 2 | %****************************************************************************** 3 | % 4 | % MATLAB (R) is a trademark of The Mathworks (R) Corporation 5 | % 6 | % Function: mtimesx_sparse 7 | % Filename: mtimesx_sparse.m 8 | % Programmer: James Tursa 9 | % Version: 1.00 10 | % Date: September 27, 2009 11 | % Copyright: (c) 2009 by James Tursa, All Rights Reserved 12 | % 13 | % This code uses the BSD License: 14 | % 15 | % Redistribution and use in source and binary forms, with or without 16 | % modification, are permitted provided that the following conditions are 17 | % met: 18 | % 19 | % * Redistributions of source code must retain the above copyright 20 | % notice, this list of conditions and the following disclaimer. 21 | % * Redistributions in binary form must reproduce the above copyright 22 | % notice, this list of conditions and the following disclaimer in 23 | % the documentation and/or other materials provided with the distribution 24 | % 25 | % THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26 | % AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 | % IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 | % ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29 | % LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 | % CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 | % SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 | % INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 | % CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 | % ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 | % POSSIBILITY OF SUCH DAMAGE. 36 | % 37 | %-- 38 | % 39 | % mtimesx_sparse is a helper function for mtimesx and is not intended to be called 40 | % directly by the user. 41 | % 42 | % --------------------------------------------------------------------------------------------------------------------------------- 43 | 44 | function result = mtimesx_sparse(a,transa,b,transb) 45 | if( transa == 'N' ) 46 | if( transb == 'N' ) 47 | result = a * b; 48 | elseif( transb == 'G' ) 49 | result = a * conj(b); 50 | elseif( transb == 'T' ) 51 | result = a * b.'; 52 | else 53 | result = a * b'; 54 | end 55 | elseif( transa == 'G' ) 56 | if( transb == 'N' ) 57 | result = conj(a) * b; 58 | elseif( transb == 'G' ) 59 | result = conj(a) * conj(b); 60 | elseif( transb == 'T' ) 61 | result = conj(a) * b.'; 62 | else 63 | result = conj(a) * b'; 64 | end 65 | elseif( transa == 'T' ) 66 | if( transb == 'N' ) 67 | result = a.' * b; 68 | elseif( transb == 'G' ) 69 | result = a.' * conj(b); 70 | elseif( transb == 'T' ) 71 | result = a.' * b.'; 72 | else 73 | result = a.' * b'; 74 | end 75 | else 76 | if( transb == 'N' ) 77 | result = a' * b; 78 | elseif( transb == 'G' ) 79 | result = a' * conj(b); 80 | elseif( transb == 'T' ) 81 | result = a' * b.'; 82 | else 83 | result = a' * b'; 84 | end 85 | end 86 | end 87 | -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx_test_ddequal.m: -------------------------------------------------------------------------------- 1 | % Test routine for mtimesx, op(double) * op(double) equality vs MATLAB 2 | %****************************************************************************** 3 | % 4 | % MATLAB (R) is a trademark of The Mathworks (R) Corporation 5 | % 6 | % Function: mtimesx_test_ddequal 7 | % Filename: mtimesx_test_ddequal.m 8 | % Programmer: James Tursa 9 | % Version: 1.0 10 | % Date: September 27, 2009 11 | % Copyright: (c) 2009 by James Tursa, All Rights Reserved 12 | % 13 | % This code uses the BSD License: 14 | % 15 | % Redistribution and use in source and binary forms, with or without 16 | % modification, are permitted provided that the following conditions are 17 | % met: 18 | % 19 | % * Redistributions of source code must retain the above copyright 20 | % notice, this list of conditions and the following disclaimer. 21 | % * Redistributions in binary form must reproduce the above copyright 22 | % notice, this list of conditions and the following disclaimer in 23 | % the documentation and/or other materials provided with the distribution 24 | % 25 | % THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26 | % AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 | % IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 | % ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29 | % LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 | % CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 | % SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 | % INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 | % CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 | % ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 | % POSSIBILITY OF SUCH DAMAGE. 36 | % 37 | % Syntax: 38 | % 39 | % T = mtimesx_test_ddequal 40 | % 41 | % Output: 42 | % 43 | % T = A character array containing a summary of the results. 44 | % 45 | %-------------------------------------------------------------------------- 46 | 47 | function dtable = mtimesx_test_ddequal 48 | 49 | global mtimesx_dtable 50 | 51 | disp(' '); 52 | disp('****************************************************************************'); 53 | disp('* *'); 54 | disp('* WARNING WARNING WARNING WARNING WARNING WARNING WARNING WARNING *'); 55 | disp('* *'); 56 | disp('* This test program can take an hour or so to complete. It is suggested *'); 57 | disp('* that you close all applications and run this program during your lunch *'); 58 | disp('* break or overnight to minimize impacts to your computer usage. *'); 59 | disp('* *'); 60 | disp('* The program will be done when you see the message: DONE ! *'); 61 | disp('* *'); 62 | disp('****************************************************************************'); 63 | disp(' '); 64 | input('Press Enter to start test, or Ctrl-C to exit ','s'); 65 | 66 | start_time = datenum(clock); 67 | 68 | compver = [computer ', ' version ', mtimesx mode ' mtimesx]; 69 | k = length(compver); 70 | RC = ' Real*Real Real*Cplx Cplx*Real Cplx*Cplx'; 71 | 72 | mtimesx_dtable = char([]); 73 | mtimesx_dtable(162,74) = ' '; 74 | mtimesx_dtable(1,1:k) = compver; 75 | mtimesx_dtable(2,:) = RC; 76 | for r=3:162 77 | mtimesx_dtable(r,:) = ' -- -- -- --'; 78 | end 79 | 80 | disp(' '); 81 | disp(compver); 82 | disp('Test program for function mtimesx:') 83 | disp('----------------------------------'); 84 | 85 | %-------------------------------------------------------------------------- 86 | %-------------------------------------------------------------------------- 87 | 88 | disp(' '); 89 | disp('Numerical Comparison Tests ...'); 90 | disp(' '); 91 | disp('(real) * (real)'); 92 | disp(' '); 93 | 94 | rsave = 2; 95 | 96 | r = rsave; 97 | 98 | %if( false ) % debug jump 99 | 100 | if( isequal([]*[],mtimesx([],[])) ) 101 | disp('Empty * Empty EQUAL'); 102 | else 103 | disp('Empty * Empty NOT EQUAL <---'); 104 | end 105 | 106 | r = r + 1; 107 | A = rand(1,1); 108 | B = rand(1,10000); 109 | maxdiffNN('Scalar * Vector ',A,B,r); 110 | 111 | r = r + 1; 112 | A = rand(1,10000); 113 | B = rand(1,1); 114 | maxdiffNN('Vector * Scalar ',A,B,r); 115 | 116 | r = r + 1; 117 | A = rand(1,1); 118 | B = rand(10,20,30,40); 119 | maxdiffNN('Scalar * Array ',A,B,r); 120 | 121 | r = r + 1; 122 | A = rand(10,20,30,40); 123 | B = rand(1,1); 124 | maxdiffNN('Array * Scalar ',A,B,r); 125 | 126 | r = r + 1; 127 | A = rand(1,10000000); 128 | B = rand(10000000,1); 129 | maxdiffNN('Vector i Vector ',A,B,r); 130 | 131 | r = r + 1; 132 | A = rand(2500,1); 133 | B = rand(1,2500); 134 | maxdiffNN('Vector o Vector ',A,B,r); 135 | 136 | r = r + 1; 137 | A = rand(1,1000); 138 | B = rand(1000,1000); 139 | maxdiffNN('Vector * Matrix ',A,B,r); 140 | 141 | r = r + 1; 142 | A = rand(1000,1000); 143 | B = rand(1000,1); 144 | maxdiffNN('Matrix * Vector ',A,B,r); 145 | 146 | r = r + 1; 147 | A = rand(1000,1000); 148 | B = rand(1000,1000); 149 | maxdiffNN('Matrix * Matrix ',A,B,r); 150 | 151 | %-------------------------------------------------------------------------- 152 | disp(' '); 153 | disp('(real) * (complex)'); 154 | disp(' '); 155 | 156 | r = rsave; 157 | 158 | r = r + 1; 159 | A = rand(1,1); 160 | B = rand(1,10000) + rand(1,10000)*1i; 161 | maxdiffNN('Scalar * Vector ',A,B,r); 162 | 163 | r = r + 1; 164 | A = rand(1,10000); 165 | B = rand(1,1) + rand(1,1)*1i; 166 | maxdiffNN('Vector * Scalar ',A,B,r); 167 | 168 | r = r + 1; 169 | A = rand(1,1); 170 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 171 | maxdiffNN('Scalar * Array ',A,B,r); 172 | 173 | r = r + 1; 174 | A = rand(10,20,30,40); 175 | B = rand(1,1) + rand(1,1)*1i; 176 | maxdiffNN('Array * Scalar ',A,B,r); 177 | 178 | r = r + 1; 179 | A = rand(1,10000000); 180 | B = rand(10000000,1) + rand(10000000,1)*1i; 181 | maxdiffNN('Vector i Vector ',A,B,r); 182 | 183 | r = r + 1; 184 | A = rand(2500,1); 185 | B = rand(1,2500) + rand(1,2500)*1i; 186 | maxdiffNN('Vector o Vector ',A,B,r); 187 | 188 | r = r + 1; 189 | A = rand(1,1000); 190 | B = rand(1000,1000) + rand(1000,1000)*1i; 191 | maxdiffNN('Vector * Matrix ',A,B,r); 192 | 193 | r = r + 1; 194 | A = rand(1000,1000); 195 | B = rand(1000,1) + rand(1000,1)*1i; 196 | maxdiffNN('Matrix * Vector ',A,B,r); 197 | 198 | r = r + 1; 199 | A = rand(1000,1000); 200 | B = rand(1000,1000) + rand(1000,1000)*1i; 201 | maxdiffNN('Matrix * Matrix ',A,B,r); 202 | 203 | %-------------------------------------------------------------------------- 204 | disp(' '); 205 | disp('(complex) * (real)'); 206 | disp(' '); 207 | 208 | r = rsave; 209 | 210 | r = r + 1; 211 | A = rand(1,1) + rand(1,1)*1i; 212 | B = rand(1,10000); 213 | maxdiffNN('Scalar * Vector ',A,B,r); 214 | 215 | r = r + 1; 216 | A = rand(1,10000)+ rand(1,10000)*1i; 217 | B = rand(1,1); 218 | maxdiffNN('Vector * Scalar ',A,B,r); 219 | 220 | r = r + 1; 221 | A = rand(1,1) + rand(1,1)*1i; 222 | B = rand(10,20,30,40); 223 | maxdiffNN('Scalar * Array ',A,B,r); 224 | 225 | r = r + 1; 226 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 227 | B = rand(1,1); 228 | maxdiffNN('Array * Scalar ',A,B,r); 229 | 230 | r = r + 1; 231 | A = rand(1,10000000) + rand(1,10000000)*1i; 232 | B = rand(10000000,1); 233 | maxdiffNN('Vector i Vector ',A,B,r); 234 | 235 | r = r + 1; 236 | A = rand(2500,1) + rand(2500,1)*1i; 237 | B = rand(1,2500); 238 | maxdiffNN('Vector o Vector ',A,B,r); 239 | 240 | r = r + 1; 241 | A = rand(1,1000) + rand(1,1000)*1i; 242 | B = rand(1000,1000); 243 | maxdiffNN('Vector * Matrix ',A,B,r); 244 | 245 | r = r + 1; 246 | A = rand(1000,1000) + rand(1000,1000)*1i; 247 | B = rand(1000,1); 248 | maxdiffNN('Matrix * Vector ',A,B,r); 249 | 250 | r = r + 1; 251 | A = rand(1000,1000) + rand(1000,1000)*1i; 252 | B = rand(1000,1000); 253 | maxdiffNN('Matrix * Matrix ',A,B,r); 254 | 255 | %-------------------------------------------------------------------------- 256 | disp(' '); 257 | disp('(complex) * (complex)'); 258 | disp(' '); 259 | 260 | r = rsave; 261 | 262 | r = r + 1; 263 | A = rand(1,1) + rand(1,1)*1i; 264 | B = rand(1,10000) + rand(1,10000)*1i; 265 | maxdiffNN('Scalar * Vector ',A,B,r); 266 | 267 | r = r + 1; 268 | A = rand(1,10000)+ rand(1,10000)*1i; 269 | B = rand(1,1) + rand(1,1)*1i; 270 | maxdiffNN('Vector * Scalar ',A,B,r); 271 | 272 | r = r + 1; 273 | A = rand(1,1) + rand(1,1)*1i; 274 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 275 | maxdiffNN('Scalar * Array ',A,B,r); 276 | 277 | r = r + 1; 278 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 279 | B = rand(1,1) + rand(1,1)*1i; 280 | maxdiffNN('Array * Scalar ',A,B,r); 281 | 282 | r = r + 1; 283 | A = rand(1,10000000) + rand(1,10000000)*1i; 284 | B = rand(10000000,1) + rand(10000000,1)*1i; 285 | maxdiffNN('Vector i Vector ',A,B,r); 286 | 287 | r = r + 1; 288 | A = rand(2500,1) + rand(2500,1)*1i; 289 | B = rand(1,2500) + rand(1,2500)*1i; 290 | maxdiffNN('Vector o Vector ',A,B,r); 291 | 292 | r = r + 1; 293 | A = rand(1,1000) + rand(1,1000)*1i; 294 | B = rand(1000,1000) + rand(1000,1000)*1i; 295 | maxdiffNN('Vector * Matrix ',A,B,r); 296 | 297 | r = r + 1; 298 | A = rand(1000,1000) + rand(1000,1000)*1i; 299 | B = rand(1000,1) + rand(1000,1)*1i; 300 | maxdiffNN('Matrix * Vector ',A,B,r); 301 | 302 | r = r + 1; 303 | A = rand(1000,1000) + rand(1000,1000)*1i; 304 | B = rand(1000,1000) + rand(1000,1000)*1i; 305 | maxdiffNN('Matrix * Matrix ',A,B,r); 306 | 307 | running_time(datenum(clock) - start_time); 308 | 309 | %-------------------------------------------------------------------------- 310 | %-------------------------------------------------------------------------- 311 | 312 | %end % debug jump 313 | 314 | disp('----------------------------------'); 315 | disp(' '); 316 | disp('Numerical Comparison Tests ...'); 317 | disp(' '); 318 | disp('(real) * (real).'''); 319 | disp(' '); 320 | 321 | if( isequal([]*[].',mtimesx([],[],'T')) ) 322 | disp('Empty * Empty.'' EQUAL'); 323 | else 324 | disp('Empty * Empty.'' NOT EQUAL <---'); 325 | end 326 | 327 | r = r + 1; 328 | mtimesx_dtable(r,:) = RC; 329 | 330 | rsave = r; 331 | 332 | r = r + 1; 333 | A = rand(1,1); 334 | B = rand(10000,1); 335 | maxdiffNT('Scalar * Vector.'' ',A,B,r); 336 | 337 | r = r + 1; 338 | A = rand(10000,1); 339 | B = rand(1,1); 340 | maxdiffNT('Vector * Scalar.'' ',A,B,r); 341 | 342 | r = r + 1; 343 | A = rand(10,20,30,40); 344 | B = rand(1,1); 345 | maxdiffNT('Array * Scalar.'' ',A,B,r); 346 | 347 | r = r + 1; 348 | A = rand(1,10000000); 349 | B = rand(1,10000000); 350 | maxdiffNT('Vector i Vector.'' ',A,B,r); 351 | 352 | r = r + 1; 353 | A = rand(2500,1); 354 | B = rand(2500,1); 355 | maxdiffNT('Vector o Vector.'' ',A,B,r); 356 | 357 | r = r + 1; 358 | A = rand(1,1000); 359 | B = rand(1000,1000); 360 | maxdiffNT('Vector * Matrix.'' ',A,B,r); 361 | 362 | r = r + 1; 363 | A = rand(1000,1000); 364 | B = rand(1,1000); 365 | maxdiffNT('Matrix * Vector.'' ',A,B,r); 366 | 367 | r = r + 1; 368 | A = rand(1000,1000); 369 | B = rand(1000,1000); 370 | maxdiffNT('Matrix * Matrix.'' ',A,B,r); 371 | 372 | %-------------------------------------------------------------------------- 373 | disp(' '); 374 | disp('(real) * (complex).'''); 375 | disp(' '); 376 | 377 | r = rsave; 378 | 379 | r = r + 1; 380 | A = rand(1,1); 381 | B = rand(1,10000) + rand(1,10000)*1i; 382 | maxdiffNT('Scalar * Vector.'' ',A,B,r); 383 | 384 | r = r + 1; 385 | A = rand(10000,1); 386 | B = rand(1,1) + rand(1,1)*1i; 387 | maxdiffNT('Vector * Scalar.'' ',A,B,r); 388 | 389 | r = r + 1; 390 | A = rand(10,20,30,40); 391 | B = rand(1,1) + rand(1,1)*1i; 392 | maxdiffNT('Array * Scalar.'' ',A,B,r); 393 | 394 | r = r + 1; 395 | A = rand(1,10000000); 396 | B = rand(1,10000000) + rand(1,10000000)*1i; 397 | maxdiffNT('Vector i Vector.'' ',A,B,r); 398 | 399 | r = r + 1; 400 | A = rand(2500,1); 401 | B = rand(2500,1) + rand(2500,1)*1i; 402 | maxdiffNT('Vector o Vector.'' ',A,B,r); 403 | 404 | r = r + 1; 405 | A = rand(1,1000); 406 | B = rand(1000,1000) + rand(1000,1000)*1i; 407 | maxdiffNT('Vector * Matrix.'' ',A,B,r); 408 | 409 | r = r + 1; 410 | A = rand(1000,1000); 411 | B = rand(1,1000) + rand(1,1000)*1i; 412 | maxdiffNT('Matrix * Vector.'' ',A,B,r); 413 | 414 | r = r + 1; 415 | A = rand(1000,1000); 416 | B = rand(1000,1000) + rand(1000,1000)*1i; 417 | maxdiffNT('Matrix * Matrix.'' ',A,B,r); 418 | 419 | %-------------------------------------------------------------------------- 420 | disp(' '); 421 | disp('(complex) * (real).'''); 422 | disp(' '); 423 | 424 | r = rsave; 425 | 426 | r = r + 1; 427 | A = rand(1,1) + rand(1,1)*1i; 428 | B = rand(1,10000); 429 | maxdiffNT('Scalar * Vector.'' ',A,B,r); 430 | 431 | r = r + 1; 432 | A = rand(10000,1)+ rand(10000,1)*1i; 433 | B = rand(1,1); 434 | maxdiffNT('Vector * Scalar.'' ',A,B,r); 435 | 436 | r = r + 1; 437 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 438 | B = rand(1,1); 439 | maxdiffNT('Array * Scalar.'' ',A,B,r); 440 | 441 | r = r + 1; 442 | A = rand(1,10000000) + rand(1,10000000)*1i; 443 | B = rand(1,10000000); 444 | maxdiffNT('Vector i Vector.'' ',A,B,r); 445 | 446 | r = r + 1; 447 | A = rand(2500,1) + rand(2500,1)*1i; 448 | B = rand(2500,1); 449 | maxdiffNT('Vector o Vector.'' ',A,B,r); 450 | 451 | r = r + 1; 452 | A = rand(1,1000) + rand(1,1000)*1i; 453 | B = rand(1000,1000); 454 | maxdiffNT('Vector * Matrix.'' ',A,B,r); 455 | 456 | r = r + 1; 457 | A = rand(1000,1000) + rand(1000,1000)*1i; 458 | B = rand(1,1000); 459 | maxdiffNT('Matrix * Vector.'' ',A,B,r); 460 | 461 | r = r + 1; 462 | A = rand(1000,1000) + rand(1000,1000)*1i; 463 | B = rand(1000,1000); 464 | maxdiffNT('Matrix * Matrix.'' ',A,B,r); 465 | 466 | %-------------------------------------------------------------------------- 467 | disp(' '); 468 | disp('(complex) * (complex).'''); 469 | disp(' '); 470 | 471 | r = rsave; 472 | 473 | r = r + 1; 474 | A = rand(1,1) + rand(1,1)*1i; 475 | B = rand(1,10000) + rand(1,10000)*1i; 476 | maxdiffNT('Scalar * Vector.'' ',A,B,r); 477 | 478 | r = r + 1; 479 | A = rand(10000,1)+ rand(10000,1)*1i; 480 | B = rand(1,1) + rand(1,1)*1i; 481 | maxdiffNT('Vector * Scalar.'' ',A,B,r); 482 | 483 | r = r + 1; 484 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 485 | B = rand(1,1) + rand(1,1)*1i; 486 | maxdiffNT('Array * Scalar.'' ',A,B,r); 487 | 488 | r = r + 1; 489 | A = rand(1,10000000) + rand(1,10000000)*1i; 490 | B = rand(1,10000000) + rand(1,10000000)*1i; 491 | maxdiffNT('Vector i Vector.'' ',A,B,r); 492 | 493 | r = r + 1; 494 | A = rand(2500,1) + rand(2500,1)*1i; 495 | B = rand(2500,1) + rand(2500,1)*1i; 496 | maxdiffNT('Vector o Vector.'' ',A,B,r); 497 | 498 | r = r + 1; 499 | A = rand(1,1000) + rand(1,1000)*1i; 500 | B = rand(1000,1000) + rand(1000,1000)*1i; 501 | maxdiffNT('Vector * Matrix.'' ',A,B,r); 502 | 503 | r = r + 1; 504 | A = rand(1000,1000) + rand(1000,1000)*1i; 505 | B = rand(1,1000) + rand(1,1000)*1i; 506 | maxdiffNT('Matrix * Vector.'' ',A,B,r); 507 | 508 | r = r + 1; 509 | A = rand(1000,1000) + rand(1000,1000)*1i; 510 | B = rand(1000,1000) + rand(1000,1000)*1i; 511 | maxdiffNT('Matrix * Matrix.'' ',A,B,r); 512 | 513 | running_time(datenum(clock) - start_time); 514 | 515 | %-------------------------------------------------------------------------- 516 | %-------------------------------------------------------------------------- 517 | 518 | %end % debug jump 519 | 520 | disp('----------------------------------'); 521 | disp(' '); 522 | disp('Numerical Comparison Tests ...'); 523 | disp(' '); 524 | disp('(real) * (real)'''); 525 | disp(' '); 526 | 527 | if( isequal([]*[]',mtimesx([],[],'C')) ) 528 | disp('Empty * Empty'' EQUAL'); 529 | else 530 | disp('Empty * Empty'' NOT EQUAL <---'); 531 | end 532 | 533 | r = r + 1; 534 | mtimesx_dtable(r,:) = RC; 535 | 536 | rsave = r; 537 | 538 | r = r + 1; 539 | A = rand(1,1); 540 | B = rand(10000,1); 541 | maxdiffNC('Scalar * Vector'' ',A,B,r); 542 | 543 | r = r + 1; 544 | A = rand(10000,1); 545 | B = rand(1,1); 546 | maxdiffNC('Vector * Scalar'' ',A,B,r); 547 | 548 | r = r + 1; 549 | A = rand(10,20,30,40); 550 | B = rand(1,1); 551 | maxdiffNC('Array * Scalar'' ',A,B,r); 552 | 553 | r = r + 1; 554 | A = rand(1,10000000); 555 | B = rand(1,10000000); 556 | maxdiffNC('Vector i Vector'' ',A,B,r); 557 | 558 | r = r + 1; 559 | A = rand(2500,1); 560 | B = rand(2500,1); 561 | maxdiffNC('Vector o Vector'' ',A,B,r); 562 | 563 | r = r + 1; 564 | A = rand(1,1000); 565 | B = rand(1000,1000); 566 | maxdiffNC('Vector * Matrix'' ',A,B,r); 567 | 568 | r = r + 1; 569 | A = rand(1000,1000); 570 | B = rand(1,1000); 571 | maxdiffNC('Matrix * Vector'' ',A,B,r); 572 | 573 | r = r + 1; 574 | A = rand(1000,1000); 575 | B = rand(1000,1000); 576 | maxdiffNC('Matrix * Matrix'' ',A,B,r); 577 | 578 | %-------------------------------------------------------------------------- 579 | disp(' '); 580 | disp('(real) * (complex)'''); 581 | disp(' '); 582 | 583 | r = rsave; 584 | 585 | r = r + 1; 586 | A = rand(1,1); 587 | B = rand(1,10000) + rand(1,10000)*1i; 588 | maxdiffNC('Scalar * Vector'' ',A,B,r); 589 | 590 | r = r + 1; 591 | A = rand(10000,1); 592 | B = rand(1,1) + rand(1,1)*1i; 593 | maxdiffNC('Vector * Scalar'' ',A,B,r); 594 | 595 | r = r + 1; 596 | A = rand(10,20,30,40); 597 | B = rand(1,1) + rand(1,1)*1i; 598 | maxdiffNC('Array * Scalar'' ',A,B,r); 599 | 600 | r = r + 1; 601 | A = rand(1,10000000); 602 | B = rand(1,10000000) + rand(1,10000000)*1i; 603 | maxdiffNC('Vector i Vector'' ',A,B,r); 604 | 605 | r = r + 1; 606 | A = rand(2500,1); 607 | B = rand(2500,1) + rand(2500,1)*1i; 608 | maxdiffNC('Vector o Vector'' ',A,B,r); 609 | 610 | r = r + 1; 611 | A = rand(1,1000); 612 | B = rand(1000,1000) + rand(1000,1000)*1i; 613 | maxdiffNC('Vector * Matrix'' ',A,B,r); 614 | 615 | r = r + 1; 616 | A = rand(1000,1000); 617 | B = rand(1,1000) + rand(1,1000)*1i; 618 | maxdiffNC('Matrix * Vector'' ',A,B,r); 619 | 620 | r = r + 1; 621 | A = rand(1000,1000); 622 | B = rand(1000,1000) + rand(1000,1000)*1i; 623 | maxdiffNC('Matrix * Matrix'' ',A,B,r); 624 | 625 | %-------------------------------------------------------------------------- 626 | disp(' '); 627 | disp('(complex) * (real)'''); 628 | disp(' '); 629 | 630 | r = rsave; 631 | 632 | r = r + 1; 633 | A = rand(1,1) + rand(1,1)*1i; 634 | B = rand(1,10000); 635 | maxdiffNC('Scalar * Vector'' ',A,B,r); 636 | 637 | r = r + 1; 638 | A = rand(10000,1)+ rand(10000,1)*1i; 639 | B = rand(1,1); 640 | maxdiffNC('Vector * Scalar'' ',A,B,r); 641 | 642 | r = r + 1; 643 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 644 | B = rand(1,1); 645 | maxdiffNC('Array * Scalar'' ',A,B,r); 646 | 647 | r = r + 1; 648 | A = rand(1,10000000) + rand(1,10000000)*1i; 649 | B = rand(1,10000000); 650 | maxdiffNC('Vector i Vector'' ',A,B,r); 651 | 652 | r = r + 1; 653 | A = rand(2500,1) + rand(2500,1)*1i; 654 | B = rand(2500,1); 655 | maxdiffNC('Vector o Vector'' ',A,B,r); 656 | 657 | r = r + 1; 658 | A = rand(1,1000) + rand(1,1000)*1i; 659 | B = rand(1000,1000); 660 | maxdiffNC('Vector * Matrix'' ',A,B,r); 661 | 662 | r = r + 1; 663 | A = rand(1000,1000) + rand(1000,1000)*1i; 664 | B = rand(1,1000); 665 | maxdiffNC('Matrix * Vector'' ',A,B,r); 666 | 667 | r = r + 1; 668 | A = rand(1000,1000) + rand(1000,1000)*1i; 669 | B = rand(1000,1000); 670 | maxdiffNC('Matrix * Matrix'' ',A,B,r); 671 | 672 | %-------------------------------------------------------------------------- 673 | disp(' '); 674 | disp('(complex) * (complex)'''); 675 | disp(' '); 676 | 677 | r = rsave; 678 | 679 | r = r + 1; 680 | A = rand(1,1) + rand(1,1)*1i; 681 | B = rand(1,10000) + rand(1,10000)*1i; 682 | maxdiffNC('Scalar * Vector'' ',A,B,r); 683 | 684 | r = r + 1; 685 | A = rand(10000,1)+ rand(10000,1)*1i; 686 | B = rand(1,1) + rand(1,1)*1i; 687 | maxdiffNC('Vector * Scalar'' ',A,B,r); 688 | 689 | r = r + 1; 690 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 691 | B = rand(1,1) + rand(1,1)*1i; 692 | maxdiffNC('Array * Scalar'' ',A,B,r); 693 | 694 | r = r + 1; 695 | A = rand(1,10000000) + rand(1,10000000)*1i; 696 | B = rand(1,10000000) + rand(1,10000000)*1i; 697 | maxdiffNC('Vector i Vector'' ',A,B,r); 698 | 699 | r = r + 1; 700 | A = rand(2500,1) + rand(2500,1)*1i; 701 | B = rand(2500,1) + rand(2500,1)*1i; 702 | maxdiffNC('Vector o Vector'' ',A,B,r); 703 | 704 | r = r + 1; 705 | A = rand(1,1000) + rand(1,1000)*1i; 706 | B = rand(1000,1000) + rand(1000,1000)*1i; 707 | maxdiffNC('Vector * Matrix'' ',A,B,r); 708 | 709 | r = r + 1; 710 | A = rand(1000,1000) + rand(1000,1000)*1i; 711 | B = rand(1,1000) + rand(1,1000)*1i; 712 | maxdiffNC('Matrix * Vector'' ',A,B,r); 713 | 714 | r = r + 1; 715 | A = rand(1000,1000) + rand(1000,1000)*1i; 716 | B = rand(1000,1000) + rand(1000,1000)*1i; 717 | maxdiffNC('Matrix * Matrix'' ',A,B,r); 718 | 719 | running_time(datenum(clock) - start_time); 720 | 721 | %-------------------------------------------------------------------------- 722 | %-------------------------------------------------------------------------- 723 | 724 | disp(' '); 725 | disp('Numerical Comparison Tests ...'); 726 | disp(' '); 727 | disp('(real) * conj(real)'); 728 | disp(' '); 729 | 730 | %if( false ) % debug jump 731 | 732 | if( isequal([]*conj([]),mtimesx([],[],'G')) ) 733 | disp('Empty * conj(Empty) EQUAL'); 734 | else 735 | disp('Empty * conj(Empty) NOT EQUAL <---'); 736 | end 737 | 738 | r = r + 1; 739 | mtimesx_dtable(r,:) = RC; 740 | 741 | r = rsave; 742 | 743 | r = r + 1; 744 | A = rand(1,1); 745 | B = rand(1,10000); 746 | maxdiffNG('Scalar * conj(Vector) ',A,B,r); 747 | 748 | r = r + 1; 749 | A = rand(1,10000); 750 | B = rand(1,1); 751 | maxdiffNG('Vector * conj(Scalar) ',A,B,r); 752 | 753 | r = r + 1; 754 | A = rand(1,1); 755 | B = rand(10,20,30,40); 756 | maxdiffNG('Scalar * conj(Array) ',A,B,r); 757 | 758 | r = r + 1; 759 | A = rand(10,20,30,40); 760 | B = rand(1,1); 761 | maxdiffNG('Array * conj(Scalar) ',A,B,r); 762 | 763 | r = r + 1; 764 | A = rand(1,10000000); 765 | B = rand(10000000,1); 766 | maxdiffNG('Vector i conj(Vector) ',A,B,r); 767 | 768 | r = r + 1; 769 | A = rand(2500,1); 770 | B = rand(1,2500); 771 | maxdiffNG('Vector o conj(Vector) ',A,B,r); 772 | 773 | r = r + 1; 774 | A = rand(1,1000); 775 | B = rand(1000,1000); 776 | maxdiffNG('Vector * conj(Matrix) ',A,B,r); 777 | 778 | r = r + 1; 779 | A = rand(1000,1000); 780 | B = rand(1000,1); 781 | maxdiffNG('Matrix * conj(Vector) ',A,B,r); 782 | 783 | r = r + 1; 784 | A = rand(1000,1000); 785 | B = rand(1000,1000); 786 | maxdiffNG('Matrix * conj(Matrix) ',A,B,r); 787 | 788 | %-------------------------------------------------------------------------- 789 | disp(' '); 790 | disp('(real) * conj(complex)'); 791 | disp(' '); 792 | 793 | r = rsave; 794 | 795 | r = r + 1; 796 | A = rand(1,1); 797 | B = rand(1,10000) + rand(1,10000)*1i; 798 | maxdiffNG('Scalar * conj(Vector) ',A,B,r); 799 | 800 | r = r + 1; 801 | A = rand(1,10000); 802 | B = rand(1,1) + rand(1,1)*1i; 803 | maxdiffNG('Vector * conj(Scalar) ',A,B,r); 804 | 805 | r = r + 1; 806 | A = rand(1,1); 807 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 808 | maxdiffNG('Scalar * conj(Array) ',A,B,r); 809 | 810 | r = r + 1; 811 | A = rand(10,20,30,40); 812 | B = rand(1,1) + rand(1,1)*1i; 813 | maxdiffNG('Array * conj(Scalar) ',A,B,r); 814 | 815 | r = r + 1; 816 | A = rand(1,10000000); 817 | B = rand(10000000,1) + rand(10000000,1)*1i; 818 | maxdiffNG('Vector i conj(Vector) ',A,B,r); 819 | 820 | r = r + 1; 821 | A = rand(2500,1); 822 | B = rand(1,2500) + rand(1,2500)*1i; 823 | maxdiffNG('Vector o conj(Vector) ',A,B,r); 824 | 825 | r = r + 1; 826 | A = rand(1,1000); 827 | B = rand(1000,1000) + rand(1000,1000)*1i; 828 | maxdiffNG('Vector * conj(Matrix) ',A,B,r); 829 | 830 | r = r + 1; 831 | A = rand(1000,1000); 832 | B = rand(1000,1) + rand(1000,1)*1i; 833 | maxdiffNG('Matrix * conj(Vector) ',A,B,r); 834 | 835 | r = r + 1; 836 | A = rand(1000,1000); 837 | B = rand(1000,1000) + rand(1000,1000)*1i; 838 | maxdiffNG('Matrix * conj(Matrix) ',A,B,r); 839 | 840 | %-------------------------------------------------------------------------- 841 | disp(' '); 842 | disp('(complex) * conj((real)'); 843 | disp(' '); 844 | 845 | r = rsave; 846 | 847 | r = r + 1; 848 | A = rand(1,1) + rand(1,1)*1i; 849 | B = rand(1,10000); 850 | maxdiffNG('Scalar * conj(Vector) ',A,B,r); 851 | 852 | r = r + 1; 853 | A = rand(1,10000)+ rand(1,10000)*1i; 854 | B = rand(1,1); 855 | maxdiffNG('Vector * conj(Scalar) ',A,B,r); 856 | 857 | r = r + 1; 858 | A = rand(1,1) + rand(1,1)*1i; 859 | B = rand(10,20,30,40); 860 | maxdiffNG('Scalar * conj(Array) ',A,B,r); 861 | 862 | r = r + 1; 863 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 864 | B = rand(1,1); 865 | maxdiffNG('Array * conj(Scalar) ',A,B,r); 866 | 867 | r = r + 1; 868 | A = rand(1,10000000) + rand(1,10000000)*1i; 869 | B = rand(10000000,1); 870 | maxdiffNG('Vector i conj(Vector) ',A,B,r); 871 | 872 | r = r + 1; 873 | A = rand(2500,1) + rand(2500,1)*1i; 874 | B = rand(1,2500); 875 | maxdiffNG('Vector o conj(Vector) ',A,B,r); 876 | 877 | r = r + 1; 878 | A = rand(1,1000) + rand(1,1000)*1i; 879 | B = rand(1000,1000); 880 | maxdiffNG('Vector * conj(Matrix) ',A,B,r); 881 | 882 | r = r + 1; 883 | A = rand(1000,1000) + rand(1000,1000)*1i; 884 | B = rand(1000,1); 885 | maxdiffNG('Matrix * conj(Vector) ',A,B,r); 886 | 887 | r = r + 1; 888 | A = rand(1000,1000) + rand(1000,1000)*1i; 889 | B = rand(1000,1000); 890 | maxdiffNG('Matrix * conj(Matrix) ',A,B,r); 891 | 892 | %-------------------------------------------------------------------------- 893 | disp(' '); 894 | disp('(complex) * conj(complex)'); 895 | disp(' '); 896 | 897 | r = rsave; 898 | 899 | r = r + 1; 900 | A = rand(1,1) + rand(1,1)*1i; 901 | B = rand(1,10000) + rand(1,10000)*1i; 902 | maxdiffNG('Scalar * conj(Vector) ',A,B,r); 903 | 904 | r = r + 1; 905 | A = rand(1,10000)+ rand(1,10000)*1i; 906 | B = rand(1,1) + rand(1,1)*1i; 907 | maxdiffNG('Vector * conj(Scalar) ',A,B,r); 908 | 909 | r = r + 1; 910 | A = rand(1,1) + rand(1,1)*1i; 911 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 912 | maxdiffNG('Scalar * conj(Array) ',A,B,r); 913 | 914 | r = r + 1; 915 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 916 | B = rand(1,1) + rand(1,1)*1i; 917 | maxdiffNG('Array * conj(Scalar) ',A,B,r); 918 | 919 | r = r + 1; 920 | A = rand(1,10000000) + rand(1,10000000)*1i; 921 | B = rand(10000000,1) + rand(10000000,1)*1i; 922 | maxdiffNG('Vector i conj(Vector) ',A,B,r); 923 | 924 | r = r + 1; 925 | A = rand(2500,1) + rand(2500,1)*1i; 926 | B = rand(1,2500) + rand(1,2500)*1i; 927 | maxdiffNG('Vector o conj(Vector) ',A,B,r); 928 | 929 | r = r + 1; 930 | A = rand(1,1000) + rand(1,1000)*1i; 931 | B = rand(1000,1000) + rand(1000,1000)*1i; 932 | maxdiffNG('Vector * conj(Matrix) ',A,B,r); 933 | 934 | r = r + 1; 935 | A = rand(1000,1000) + rand(1000,1000)*1i; 936 | B = rand(1000,1) + rand(1000,1)*1i; 937 | maxdiffNG('Matrix * conj(Vector) ',A,B,r); 938 | 939 | r = r + 1; 940 | A = rand(1000,1000) + rand(1000,1000)*1i; 941 | B = rand(1000,1000) + rand(1000,1000)*1i; 942 | maxdiffNG('Matrix * conj(Matrix) ',A,B,r); 943 | 944 | running_time(datenum(clock) - start_time); 945 | 946 | %-------------------------------------------------------------------------- 947 | %-------------------------------------------------------------------------- 948 | 949 | disp('----------------------------------'); 950 | disp(' '); 951 | disp('Numerical Comparison Tests ...'); 952 | disp(' '); 953 | disp('(real).'' * (real)'); 954 | disp(' '); 955 | 956 | if( isequal([]'*[],mtimesx([],'C',[])) ) 957 | disp('Empty.'' * Empty EQUAL'); 958 | else 959 | disp('Empty.'' * Empty NOT EQUAL <---'); 960 | end 961 | 962 | r = r + 1; 963 | mtimesx_dtable(r,:) = RC; 964 | 965 | rsave = r; 966 | 967 | r = r + 1; 968 | A = rand(1,1); 969 | B = rand(1,10000); 970 | maxdiffTN('Scalar.'' * Vector ',A,B,r); 971 | 972 | r = r + 1; 973 | A = rand(10000,1); 974 | B = rand(1,1); 975 | maxdiffTN('Vector.'' * Scalar ',A,B,r); 976 | 977 | r = r + 1; 978 | A = rand(1,1); 979 | B = rand(10,20,30,40); 980 | maxdiffTN('Scalar.'' * Array ',A,B,r); 981 | 982 | r = r + 1; 983 | A = rand(10000000,1); 984 | B = rand(10000000,1); 985 | maxdiffTN('Vector.'' i Vector ',A,B,r); 986 | 987 | r = r + 1; 988 | A = rand(1,2500); 989 | B = rand(1,2500); 990 | maxdiffTN('Vector.'' o Vector ',A,B,r); 991 | 992 | r = r + 1; 993 | A = rand(1000,1); 994 | B = rand(1000,1000); 995 | maxdiffTN('Vector.'' * Matrix ',A,B,r); 996 | 997 | r = r + 1; 998 | A = rand(1000,1000); 999 | B = rand(1000,1); 1000 | maxdiffTN('Matrix.'' * Vector ',A,B,r); 1001 | 1002 | r = r + 1; 1003 | A = rand(1000,1000); 1004 | B = rand(1000,1000); 1005 | maxdiffTN('Matrix.'' * Matrix ',A,B,r); 1006 | 1007 | %-------------------------------------------------------------------------- 1008 | disp(' '); 1009 | disp('(real).'' * (complex)'); 1010 | disp(' '); 1011 | 1012 | r = rsave; 1013 | 1014 | r = r + 1; 1015 | A = rand(1,1); 1016 | B = rand(1,10000) + rand(1,10000)*1i; 1017 | maxdiffTN('Scalar.'' * Vector ',A,B,r); 1018 | 1019 | r = r + 1; 1020 | A = rand(10000,1); 1021 | B = rand(1,1) + rand(1,1)*1i; 1022 | maxdiffTN('Vector.'' * Scalar ',A,B,r); 1023 | 1024 | r = r + 1; 1025 | A = rand(1,1); 1026 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 1027 | maxdiffTN('Scalar.'' * Array ',A,B,r); 1028 | 1029 | r = r + 1; 1030 | A = rand(10000000,1); 1031 | B = rand(10000000,1) + rand(10000000,1)*1i; 1032 | maxdiffTN('Vector.'' i Vector ',A,B,r); 1033 | 1034 | r = r + 1; 1035 | A = rand(1,2500); 1036 | B = rand(1,2500) + rand(1,2500)*1i; 1037 | maxdiffTN('Vector.'' o Vector ',A,B,r); 1038 | 1039 | r = r + 1; 1040 | A = rand(1000,1); 1041 | B = rand(1000,1000) + rand(1000,1000)*1i; 1042 | maxdiffTN('Vector.'' * Matrix ',A,B,r); 1043 | 1044 | r = r + 1; 1045 | A = rand(1000,1000); 1046 | B = rand(1000,1) + rand(1000,1)*1i; 1047 | maxdiffTN('Matrix.'' * Vector ',A,B,r); 1048 | 1049 | r = r + 1; 1050 | A = rand(1000,1000); 1051 | B = rand(1000,1000) + rand(1000,1000)*1i; 1052 | maxdiffTN('Matrix.'' * Matrix ',A,B,r); 1053 | 1054 | %-------------------------------------------------------------------------- 1055 | disp(' '); 1056 | disp('(complex).'' * (real)'); 1057 | disp(' '); 1058 | 1059 | r = rsave; 1060 | 1061 | r = r + 1; 1062 | A = rand(1,1) + rand(1,1)*1i; 1063 | B = rand(1,10000); 1064 | maxdiffTN('Scalar.'' * Vector ',A,B,r); 1065 | 1066 | r = r + 1; 1067 | A = rand(10000,1)+ rand(10000,1)*1i; 1068 | B = rand(1,1); 1069 | maxdiffTN('Vector.'' * Scalar ',A,B,r); 1070 | 1071 | r = r + 1; 1072 | A = rand(1,1) + rand(1,1)*1i; 1073 | B = rand(10,20,30,40); 1074 | maxdiffTN('Scalar.'' * Array ',A,B,r); 1075 | 1076 | r = r + 1; 1077 | A = rand(10000000,1) + rand(10000000,1)*1i; 1078 | B = rand(10000000,1); 1079 | maxdiffTN('Vector.'' i Vector ',A,B,r); 1080 | 1081 | r = r + 1; 1082 | A = rand(1,2500) + rand(1,2500)*1i; 1083 | B = rand(1,2500); 1084 | maxdiffTN('Vector.'' o Vector ',A,B,r); 1085 | 1086 | r = r + 1; 1087 | A = rand(1000,1) + rand(1000,1)*1i; 1088 | B = rand(1000,1000); 1089 | maxdiffTN('Vector.'' * Matrix ',A,B,r); 1090 | 1091 | r = r + 1; 1092 | A = rand(1000,1000) + rand(1000,1000)*1i; 1093 | B = rand(1000,1); 1094 | maxdiffTN('Matrix.'' * Vector ',A,B,r); 1095 | 1096 | r = r + 1; 1097 | A = rand(1000,1000) + rand(1000,1000)*1i; 1098 | B = rand(1000,1000); 1099 | maxdiffTN('Matrix.'' * Matrix ',A,B,r); 1100 | 1101 | %-------------------------------------------------------------------------- 1102 | disp(' '); 1103 | disp('(complex).'' * (complex)'); 1104 | disp(' '); 1105 | 1106 | r = rsave; 1107 | 1108 | r = r + 1; 1109 | A = rand(1,1) + rand(1,1)*1i; 1110 | B = rand(1,10000) + rand(1,10000)*1i; 1111 | maxdiffTN('Scalar.'' * Vector ',A,B,r); 1112 | 1113 | r = r + 1; 1114 | A = rand(10000,1)+ rand(10000,1)*1i; 1115 | B = rand(1,1) + rand(1,1)*1i; 1116 | maxdiffTN('Vector.'' * Scalar ',A,B,r); 1117 | 1118 | r = r + 1; 1119 | A = rand(1,1) + rand(1,1)*1i; 1120 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 1121 | maxdiffTN('Scalar.'' * Array ',A,B,r); 1122 | 1123 | r = r + 1; 1124 | A = rand(10000000,1) + rand(10000000,1)*1i; 1125 | B = rand(10000000,1) + rand(10000000,1)*1i; 1126 | maxdiffTN('Vector.'' i Vector ',A,B,r); 1127 | 1128 | r = r + 1; 1129 | A = rand(1,2500) + rand(1,2500)*1i; 1130 | B = rand(1,2500) + rand(1,2500)*1i; 1131 | maxdiffTN('Vector.'' o Vector ',A,B,r); 1132 | 1133 | r = r + 1; 1134 | A = rand(1000,1) + rand(1000,1)*1i; 1135 | B = rand(1000,1000) + rand(1000,1000)*1i; 1136 | maxdiffTN('Vector.'' * Matrix ',A,B,r); 1137 | 1138 | r = r + 1; 1139 | A = rand(1000,1000) + rand(1000,1000)*1i; 1140 | B = rand(1000,1) + rand(1000,1)*1i; 1141 | maxdiffTN('Matrix.'' * Vector ',A,B,r); 1142 | 1143 | r = r + 1; 1144 | A = rand(1000,1000) + rand(1000,1000)*1i; 1145 | B = rand(1000,1000) + rand(1000,1000)*1i; 1146 | maxdiffTN('Matrix.'' * Matrix ',A,B,r); 1147 | 1148 | running_time(datenum(clock) - start_time); 1149 | 1150 | %-------------------------------------------------------------------------- 1151 | %-------------------------------------------------------------------------- 1152 | 1153 | %end % debug jump 1154 | 1155 | disp('----------------------------------'); 1156 | disp(' '); 1157 | disp('Numerical Comparison Tests ...'); 1158 | disp(' '); 1159 | disp('(real).'' * (real).'''); 1160 | disp(' '); 1161 | 1162 | if( isequal([].'*[]',mtimesx([],'T',[],'C')) ) 1163 | disp('Empty.'' * Empty.'' EQUAL'); 1164 | else 1165 | disp('Empty.'' * Empty.'' NOT EQUAL <---'); 1166 | end 1167 | 1168 | r = r + 1; 1169 | mtimesx_dtable(r,:) = RC; 1170 | 1171 | rsave = r; 1172 | 1173 | r = r + 1; 1174 | A = rand(1,1); 1175 | B = rand(10000,1); 1176 | maxdiffTT('Scalar.'' * Vector.'' ',A,B,r); 1177 | 1178 | r = r + 1; 1179 | A = rand(10000,1); 1180 | B = rand(1,1); 1181 | maxdiffTT('Vector.'' * Scalar.'' ',A,B,r); 1182 | 1183 | r = r + 1; 1184 | A = rand(10000000,1); 1185 | B = rand(1,10000000); 1186 | maxdiffTT('Vector.'' i Vector.'' ',A,B,r); 1187 | 1188 | r = r + 1; 1189 | A = rand(1,2500); 1190 | B = rand(2500,1); 1191 | maxdiffTT('Vector.'' o Vector.'' ',A,B,r); 1192 | 1193 | r = r + 1; 1194 | A = rand(1000,1); 1195 | B = rand(1000,1000); 1196 | maxdiffTT('Vector.'' * Matrix.'' ',A,B,r); 1197 | 1198 | r = r + 1; 1199 | A = rand(1000,1000); 1200 | B = rand(1,1000); 1201 | maxdiffTT('Matrix.'' * Vector.'' ',A,B,r); 1202 | 1203 | r = r + 1; 1204 | A = rand(1000,1000); 1205 | B = rand(1000,1000); 1206 | maxdiffTT('Matrix.'' * Matrix.'' ',A,B,r); 1207 | 1208 | %-------------------------------------------------------------------------- 1209 | disp(' '); 1210 | disp('(real).'' * (complex).'''); 1211 | disp(' '); 1212 | 1213 | r = rsave; 1214 | 1215 | r = r + 1; 1216 | A = rand(1,1); 1217 | B = rand(1,10000) + rand(1,10000)*1i; 1218 | maxdiffTT('Scalar.'' * Vector.'' ',A,B,r); 1219 | 1220 | r = r + 1; 1221 | A = rand(10000,1); 1222 | B = rand(1,1) + rand(1,1)*1i; 1223 | maxdiffTT('Vector.'' * Scalar.'' ',A,B,r); 1224 | 1225 | r = r + 1; 1226 | A = rand(10000000,1); 1227 | B = rand(1,10000000) + rand(1,10000000)*1i; 1228 | maxdiffTT('Vector.'' i Vector.'' ',A,B,r); 1229 | 1230 | r = r + 1; 1231 | A = rand(1,2500); 1232 | B = rand(2500,1) + rand(2500,1)*1i; 1233 | maxdiffTT('Vector.'' o Vector.'' ',A,B,r); 1234 | 1235 | r = r + 1; 1236 | A = rand(1000,1); 1237 | B = rand(1000,1000) + rand(1000,1000)*1i; 1238 | maxdiffTT('Vector.'' * Matrix.'' ',A,B,r); 1239 | 1240 | r = r + 1; 1241 | A = rand(1000,1000); 1242 | B = rand(1,1000) + rand(1,1000)*1i; 1243 | maxdiffTT('Matrix.'' * Vector.'' ',A,B,r); 1244 | 1245 | r = r + 1; 1246 | A = rand(1000,1000); 1247 | B = rand(1000,1000) + rand(1000,1000)*1i; 1248 | maxdiffTT('Matrix.'' * Matrix.'' ',A,B,r); 1249 | 1250 | %-------------------------------------------------------------------------- 1251 | disp(' '); 1252 | disp('(complex).'' * (real).'''); 1253 | disp(' '); 1254 | 1255 | r = rsave; 1256 | 1257 | r = r + 1; 1258 | A = rand(1,1) + rand(1,1)*1i; 1259 | B = rand(1,10000); 1260 | maxdiffTT('Scalar.'' * Vector.'' ',A,B,r); 1261 | 1262 | r = r + 1; 1263 | A = rand(10000,1)+ rand(10000,1)*1i; 1264 | B = rand(1,1); 1265 | maxdiffTT('Vector.'' * Scalar.'' ',A,B,r); 1266 | 1267 | r = r + 1; 1268 | A = rand(10000000,1) + rand(10000000,1)*1i; 1269 | B = rand(1,10000000); 1270 | maxdiffTT('Vector.'' i Vector.'' ',A,B,r); 1271 | 1272 | r = r + 1; 1273 | A = rand(1,2500) + rand(1,2500)*1i; 1274 | B = rand(2500,1); 1275 | maxdiffTT('Vector.'' o Vector.'' ',A,B,r); 1276 | 1277 | r = r + 1; 1278 | A = rand(1000,1) + rand(1000,1)*1i; 1279 | B = rand(1000,1000); 1280 | maxdiffTT('Vector.'' * Matrix.'' ',A,B,r); 1281 | 1282 | r = r + 1; 1283 | A = rand(1000,1000) + rand(1000,1000)*1i; 1284 | B = rand(1,1000); 1285 | maxdiffTT('Matrix.'' * Vector.'' ',A,B,r); 1286 | 1287 | r = r + 1; 1288 | A = rand(1000,1000) + rand(1000,1000)*1i; 1289 | B = rand(1000,1000); 1290 | maxdiffTT('Matrix.'' * Matrix.'' ',A,B,r); 1291 | 1292 | %-------------------------------------------------------------------------- 1293 | disp(' '); 1294 | disp('(complex).'' * (complex).'''); 1295 | disp(' '); 1296 | 1297 | r = rsave; 1298 | 1299 | r = r + 1; 1300 | A = rand(1,1) + rand(1,1)*1i; 1301 | B = rand(1,10000) + rand(1,10000)*1i; 1302 | maxdiffTT('Scalar.'' * Vector.'' ',A,B,r); 1303 | 1304 | r = r + 1; 1305 | A = rand(10000,1)+ rand(10000,1)*1i; 1306 | B = rand(1,1) + rand(1,1)*1i; 1307 | maxdiffTT('Vector.'' * Scalar.'' ',A,B,r); 1308 | 1309 | r = r + 1; 1310 | A = rand(10000000,1) + rand(10000000,1)*1i; 1311 | B = rand(1,10000000) + rand(1,10000000)*1i; 1312 | maxdiffTT('Vector.'' i Vector.'' ',A,B,r); 1313 | 1314 | r = r + 1; 1315 | A = rand(1,2500) + rand(1,2500)*1i; 1316 | B = rand(2500,1) + rand(2500,1)*1i; 1317 | maxdiffTT('Vector.'' o Vector.'' ',A,B,r); 1318 | 1319 | r = r + 1; 1320 | A = rand(1000,1) + rand(1000,1)*1i; 1321 | B = rand(1000,1000) + rand(1000,1000)*1i; 1322 | maxdiffTT('Vector.'' * Matrix.'' ',A,B,r); 1323 | 1324 | r = r + 1; 1325 | A = rand(1000,1000) + rand(1000,1000)*1i; 1326 | B = rand(1,1000) + rand(1,1000)*1i; 1327 | maxdiffTT('Matrix.'' * Vector.'' ',A,B,r); 1328 | 1329 | r = r + 1; 1330 | A = rand(1000,1000) + rand(1000,1000)*1i; 1331 | B = rand(1000,1000) + rand(1000,1000)*1i; 1332 | maxdiffTT('Matrix.'' * Matrix.'' ',A,B,r); 1333 | 1334 | running_time(datenum(clock) - start_time); 1335 | 1336 | %-------------------------------------------------------------------------- 1337 | %-------------------------------------------------------------------------- 1338 | 1339 | %end % debug jump 1340 | 1341 | disp('----------------------------------'); 1342 | disp(' '); 1343 | disp('Numerical Comparison Tests ...'); 1344 | disp(' '); 1345 | disp('(real).'' * (real)'''); 1346 | disp(' '); 1347 | 1348 | if( isequal([].'*[]',mtimesx([],'T',[],'C')) ) 1349 | disp('Empty.'' * Empty'' EQUAL'); 1350 | else 1351 | disp('Empty.'' * Empty'' NOT EQUAL <---'); 1352 | end 1353 | 1354 | r = r + 1; 1355 | mtimesx_dtable(r,:) = RC; 1356 | 1357 | rsave = r; 1358 | 1359 | r = r + 1; 1360 | A = rand(1,1); 1361 | B = rand(10000,1); 1362 | maxdiffTC('Scalar.'' * Vector'' ',A,B,r); 1363 | 1364 | r = r + 1; 1365 | A = rand(10000,1); 1366 | B = rand(1,1); 1367 | maxdiffTC('Vector.'' * Scalar'' ',A,B,r); 1368 | 1369 | r = r + 1; 1370 | A = rand(10000000,1); 1371 | B = rand(1,10000000); 1372 | maxdiffTC('Vector.'' i Vector'' ',A,B,r); 1373 | 1374 | r = r + 1; 1375 | A = rand(1,2500); 1376 | B = rand(2500,1); 1377 | maxdiffTC('Vector.'' o Vector'' ',A,B,r); 1378 | 1379 | r = r + 1; 1380 | A = rand(1000,1); 1381 | B = rand(1000,1000); 1382 | maxdiffTC('Vector.'' * Matrix'' ',A,B,r); 1383 | 1384 | r = r + 1; 1385 | A = rand(1000,1000); 1386 | B = rand(1,1000); 1387 | maxdiffTC('Matrix.'' * Vector'' ',A,B,r); 1388 | 1389 | r = r + 1; 1390 | A = rand(1000,1000); 1391 | B = rand(1000,1000); 1392 | maxdiffTC('Matrix.'' * Matrix'' ',A,B,r); 1393 | 1394 | %-------------------------------------------------------------------------- 1395 | disp(' '); 1396 | disp('(real).'' * (complex)'''); 1397 | disp(' '); 1398 | 1399 | r = rsave; 1400 | 1401 | r = r + 1; 1402 | A = rand(1,1); 1403 | B = rand(1,10000) + rand(1,10000)*1i; 1404 | maxdiffTC('Scalar.'' * Vector'' ',A,B,r); 1405 | 1406 | r = r + 1; 1407 | A = rand(10000,1); 1408 | B = rand(1,1) + rand(1,1)*1i; 1409 | maxdiffTC('Vector.'' * Scalar'' ',A,B,r); 1410 | 1411 | r = r + 1; 1412 | A = rand(10000000,1); 1413 | B = rand(1,10000000) + rand(1,10000000)*1i; 1414 | maxdiffTC('Vector.'' i Vector'' ',A,B,r); 1415 | 1416 | r = r + 1; 1417 | A = rand(1,2500); 1418 | B = rand(2500,1) + rand(2500,1)*1i; 1419 | maxdiffTC('Vector.'' o Vector'' ',A,B,r); 1420 | 1421 | r = r + 1; 1422 | A = rand(1000,1); 1423 | B = rand(1000,1000) + rand(1000,1000)*1i; 1424 | maxdiffTC('Vector.'' * Matrix'' ',A,B,r); 1425 | 1426 | r = r + 1; 1427 | A = rand(1000,1000); 1428 | B = rand(1,1000) + rand(1,1000)*1i; 1429 | maxdiffTC('Matrix.'' * Vector'' ',A,B,r); 1430 | 1431 | r = r + 1; 1432 | A = rand(1000,1000); 1433 | B = rand(1000,1000) + rand(1000,1000)*1i; 1434 | maxdiffTC('Matrix.'' * Matrix'' ',A,B,r); 1435 | 1436 | %-------------------------------------------------------------------------- 1437 | disp(' '); 1438 | disp('(complex).'' * (real)'''); 1439 | disp(' '); 1440 | 1441 | r = rsave; 1442 | 1443 | r = r + 1; 1444 | A = rand(1,1) + rand(1,1)*1i; 1445 | B = rand(1,10000); 1446 | maxdiffTC('Scalar.'' * Vector'' ',A,B,r); 1447 | 1448 | r = r + 1; 1449 | A = rand(10000,1)+ rand(10000,1)*1i; 1450 | B = rand(1,1); 1451 | maxdiffTC('Vector.'' * Scalar'' ',A,B,r); 1452 | 1453 | r = r + 1; 1454 | A = rand(10000000,1) + rand(10000000,1)*1i; 1455 | B = rand(1,10000000); 1456 | maxdiffTC('Vector.'' i Vector'' ',A,B,r); 1457 | 1458 | r = r + 1; 1459 | A = rand(1,2500) + rand(1,2500)*1i; 1460 | B = rand(2500,1); 1461 | maxdiffTC('Vector.'' o Vector'' ',A,B,r); 1462 | 1463 | r = r + 1; 1464 | A = rand(1000,1) + rand(1000,1)*1i; 1465 | B = rand(1000,1000); 1466 | maxdiffTC('Vector.'' * Matrix'' ',A,B,r); 1467 | 1468 | r = r + 1; 1469 | A = rand(1000,1000) + rand(1000,1000)*1i; 1470 | B = rand(1,1000); 1471 | maxdiffTC('Matrix.'' * Vector'' ',A,B,r); 1472 | 1473 | r = r + 1; 1474 | A = rand(1000,1000) + rand(1000,1000)*1i; 1475 | B = rand(1000,1000); 1476 | maxdiffTC('Matrix.'' * Matrix'' ',A,B,r); 1477 | 1478 | %-------------------------------------------------------------------------- 1479 | disp(' '); 1480 | disp('(complex).'' * (complex)'''); 1481 | disp(' '); 1482 | 1483 | r = rsave; 1484 | 1485 | r = r + 1; 1486 | A = rand(1,1) + rand(1,1)*1i; 1487 | B = rand(1,10000) + rand(1,10000)*1i; 1488 | maxdiffTC('Scalar.'' * Vector'' ',A,B,r); 1489 | 1490 | r = r + 1; 1491 | A = rand(10000,1)+ rand(10000,1)*1i; 1492 | B = rand(1,1) + rand(1,1)*1i; 1493 | maxdiffTC('Vector.'' * Scalar'' ',A,B,r); 1494 | 1495 | r = r + 1; 1496 | A = rand(10000000,1) + rand(10000000,1)*1i; 1497 | B = rand(1,10000000) + rand(1,10000000)*1i; 1498 | maxdiffTC('Vector.'' i Vector'' ',A,B,r); 1499 | 1500 | r = r + 1; 1501 | A = rand(1,2500) + rand(1,2500)*1i; 1502 | B = rand(2500,1) + rand(2500,1)*1i; 1503 | maxdiffTC('Vector.'' o Vector'' ',A,B,r); 1504 | 1505 | r = r + 1; 1506 | A = rand(1000,1) + rand(1000,1)*1i; 1507 | B = rand(1000,1000) + rand(1000,1000)*1i; 1508 | maxdiffTC('Vector.'' * Matrix'' ',A,B,r); 1509 | 1510 | r = r + 1; 1511 | A = rand(1000,1000) + rand(1000,1000)*1i; 1512 | B = rand(1,1000) + rand(1,1000)*1i; 1513 | maxdiffTC('Matrix.'' * Vector'' ',A,B,r); 1514 | 1515 | r = r + 1; 1516 | A = rand(1000,1000) + rand(1000,1000)*1i; 1517 | B = rand(1000,1000) + rand(1000,1000)*1i; 1518 | maxdiffTC('Matrix.'' * Matrix'' ',A,B,r); 1519 | 1520 | running_time(datenum(clock) - start_time); 1521 | 1522 | %-------------------------------------------------------------------------- 1523 | %-------------------------------------------------------------------------- 1524 | 1525 | disp('----------------------------------'); 1526 | disp(' '); 1527 | disp('Numerical Comparison Tests ...'); 1528 | disp(' '); 1529 | disp('(real).'' * conj(real)'); 1530 | disp(' '); 1531 | 1532 | if( isequal([]'*conj([]),mtimesx([],'C',[],'G')) ) 1533 | disp('Empty.'' * conj(Empty) EQUAL'); 1534 | else 1535 | disp('Empty.'' * conj(Empty) NOT EQUAL <---'); 1536 | end 1537 | 1538 | r = r + 1; 1539 | mtimesx_dtable(r,:) = RC; 1540 | 1541 | rsave = r; 1542 | 1543 | r = r + 1; 1544 | A = rand(1,1); 1545 | B = rand(1,10000); 1546 | maxdiffTG('Scalar.'' * conj(Vector) ',A,B,r); 1547 | 1548 | r = r + 1; 1549 | A = rand(10000,1); 1550 | B = rand(1,1); 1551 | maxdiffTG('Vector.'' * conj(Scalar) ',A,B,r); 1552 | 1553 | r = r + 1; 1554 | A = rand(1,1); 1555 | B = rand(10,20,30,40); 1556 | maxdiffTG('Scalar.'' * conj(Array) ',A,B,r); 1557 | 1558 | r = r + 1; 1559 | A = rand(10000000,1); 1560 | B = rand(10000000,1); 1561 | maxdiffTG('Vector.'' i conj(Vector) ',A,B,r); 1562 | 1563 | r = r + 1; 1564 | A = rand(1,2500); 1565 | B = rand(1,2500); 1566 | maxdiffTG('Vector.'' o conj(Vector) ',A,B,r); 1567 | 1568 | r = r + 1; 1569 | A = rand(1000,1); 1570 | B = rand(1000,1000); 1571 | maxdiffTG('Vector.'' * conj(Matrix) ',A,B,r); 1572 | 1573 | r = r + 1; 1574 | A = rand(1000,1000); 1575 | B = rand(1000,1); 1576 | maxdiffTG('Matrix.'' * conj(Vector) ',A,B,r); 1577 | 1578 | r = r + 1; 1579 | A = rand(1000,1000); 1580 | B = rand(1000,1000); 1581 | maxdiffTG('Matrix.'' * conj(Matrix) ',A,B,r); 1582 | 1583 | %-------------------------------------------------------------------------- 1584 | disp(' '); 1585 | disp('(real).'' * conj(complex)'); 1586 | disp(' '); 1587 | 1588 | r = rsave; 1589 | 1590 | r = r + 1; 1591 | A = rand(1,1); 1592 | B = rand(1,10000) + rand(1,10000)*1i; 1593 | maxdiffTG('Scalar.'' * conj(Vector) ',A,B,r); 1594 | 1595 | r = r + 1; 1596 | A = rand(10000,1); 1597 | B = rand(1,1) + rand(1,1)*1i; 1598 | maxdiffTG('Vector.'' * conj(Scalar) ',A,B,r); 1599 | 1600 | r = r + 1; 1601 | A = rand(1,1); 1602 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 1603 | maxdiffTG('Scalar.'' * conj(Array) ',A,B,r); 1604 | 1605 | r = r + 1; 1606 | A = rand(10000000,1); 1607 | B = rand(10000000,1) + rand(10000000,1)*1i; 1608 | maxdiffTG('Vector.'' i conj(Vector) ',A,B,r); 1609 | 1610 | r = r + 1; 1611 | A = rand(1,2500); 1612 | B = rand(1,2500) + rand(1,2500)*1i; 1613 | maxdiffTG('Vector.'' o conj(Vector) ',A,B,r); 1614 | 1615 | r = r + 1; 1616 | A = rand(1000,1); 1617 | B = rand(1000,1000) + rand(1000,1000)*1i; 1618 | maxdiffTG('Vector.'' * conj(Matrix) ',A,B,r); 1619 | 1620 | r = r + 1; 1621 | A = rand(1000,1000); 1622 | B = rand(1000,1) + rand(1000,1)*1i; 1623 | maxdiffTG('Matrix.'' * conj(Vector) ',A,B,r); 1624 | 1625 | r = r + 1; 1626 | A = rand(1000,1000); 1627 | B = rand(1000,1000) + rand(1000,1000)*1i; 1628 | maxdiffTG('Matrix.'' * conj(Matrix) ',A,B,r); 1629 | 1630 | %-------------------------------------------------------------------------- 1631 | disp(' '); 1632 | disp('(complex).'' * conj(real)'); 1633 | disp(' '); 1634 | 1635 | r = rsave; 1636 | 1637 | r = r + 1; 1638 | A = rand(1,1) + rand(1,1)*1i; 1639 | B = rand(1,10000); 1640 | maxdiffTG('Scalar.'' * conj(Vector) ',A,B,r); 1641 | 1642 | r = r + 1; 1643 | A = rand(10000,1)+ rand(10000,1)*1i; 1644 | B = rand(1,1); 1645 | maxdiffTG('Vector.'' * conj(Scalar) ',A,B,r); 1646 | 1647 | r = r + 1; 1648 | A = rand(1,1) + rand(1,1)*1i; 1649 | B = rand(10,20,30,40); 1650 | maxdiffTG('Scalar.'' * conj(Array) ',A,B,r); 1651 | 1652 | r = r + 1; 1653 | A = rand(10000000,1) + rand(10000000,1)*1i; 1654 | B = rand(10000000,1); 1655 | maxdiffTG('Vector.'' i conj(Vector) ',A,B,r); 1656 | 1657 | r = r + 1; 1658 | A = rand(1,2500) + rand(1,2500)*1i; 1659 | B = rand(1,2500); 1660 | maxdiffTG('Vector.'' o conj(Vector) ',A,B,r); 1661 | 1662 | r = r + 1; 1663 | A = rand(1000,1) + rand(1000,1)*1i; 1664 | B = rand(1000,1000); 1665 | maxdiffTG('Vector.'' * conj(Matrix) ',A,B,r); 1666 | 1667 | r = r + 1; 1668 | A = rand(1000,1000) + rand(1000,1000)*1i; 1669 | B = rand(1000,1); 1670 | maxdiffTG('Matrix.'' * conj(Vector) ',A,B,r); 1671 | 1672 | r = r + 1; 1673 | A = rand(1000,1000) + rand(1000,1000)*1i; 1674 | B = rand(1000,1000); 1675 | maxdiffTG('Matrix.'' * conj(Matrix) ',A,B,r); 1676 | 1677 | %-------------------------------------------------------------------------- 1678 | disp(' '); 1679 | disp('(complex).'' * conj(complex)'); 1680 | disp(' '); 1681 | 1682 | r = rsave; 1683 | 1684 | r = r + 1; 1685 | A = rand(1,1) + rand(1,1)*1i; 1686 | B = rand(1,10000) + rand(1,10000)*1i; 1687 | maxdiffTG('Scalar.'' * conj(Vector) ',A,B,r); 1688 | 1689 | r = r + 1; 1690 | A = rand(10000,1)+ rand(10000,1)*1i; 1691 | B = rand(1,1) + rand(1,1)*1i; 1692 | maxdiffTG('Vector.'' * conj(Scalar) ',A,B,r); 1693 | 1694 | r = r + 1; 1695 | A = rand(1,1) + rand(1,1)*1i; 1696 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 1697 | maxdiffTG('Scalar.'' * conj(Array) ',A,B,r); 1698 | 1699 | r = r + 1; 1700 | A = rand(10000000,1) + rand(10000000,1)*1i; 1701 | B = rand(10000000,1) + rand(10000000,1)*1i; 1702 | maxdiffTG('Vector.'' i conj(Vector) ',A,B,r); 1703 | 1704 | r = r + 1; 1705 | A = rand(1,2500) + rand(1,2500)*1i; 1706 | B = rand(1,2500) + rand(1,2500)*1i; 1707 | maxdiffTG('Vector.'' o conj(Vector) ',A,B,r); 1708 | 1709 | r = r + 1; 1710 | A = rand(1000,1) + rand(1000,1)*1i; 1711 | B = rand(1000,1000) + rand(1000,1000)*1i; 1712 | maxdiffTG('Vector.'' * conj(Matrix) ',A,B,r); 1713 | 1714 | r = r + 1; 1715 | A = rand(1000,1000) + rand(1000,1000)*1i; 1716 | B = rand(1000,1) + rand(1000,1)*1i; 1717 | maxdiffTG('Matrix.'' * conj(Vector) ',A,B,r); 1718 | 1719 | r = r + 1; 1720 | A = rand(1000,1000) + rand(1000,1000)*1i; 1721 | B = rand(1000,1000) + rand(1000,1000)*1i; 1722 | maxdiffTG('Matrix.'' * conj(Matrix) ',A,B,r); 1723 | 1724 | running_time(datenum(clock) - start_time); 1725 | 1726 | %-------------------------------------------------------------------------- 1727 | %-------------------------------------------------------------------------- 1728 | 1729 | disp('----------------------------------'); 1730 | disp(' '); 1731 | disp('Numerical Comparison Tests ...'); 1732 | disp(' '); 1733 | disp('(real)'' * (real)'); 1734 | disp(' '); 1735 | 1736 | if( isequal([]'*[],mtimesx([],'C',[])) ) 1737 | disp('Empty'' * Empty EQUAL'); 1738 | else 1739 | disp('Empty'' * Empty NOT EQUAL <---'); 1740 | end 1741 | 1742 | r = r + 1; 1743 | mtimesx_dtable(r,:) = RC; 1744 | 1745 | rsave = r; 1746 | 1747 | r = r + 1; 1748 | A = rand(1,1); 1749 | B = rand(1,10000); 1750 | maxdiffCN('Scalar'' * Vector ',A,B,r); 1751 | 1752 | r = r + 1; 1753 | A = rand(10000,1); 1754 | B = rand(1,1); 1755 | maxdiffCN('Vector'' * Scalar ',A,B,r); 1756 | 1757 | r = r + 1; 1758 | A = rand(1,1); 1759 | B = rand(10,20,30,40); 1760 | maxdiffCN('Scalar'' * Array ',A,B,r); 1761 | 1762 | r = r + 1; 1763 | A = rand(10000000,1); 1764 | B = rand(10000000,1); 1765 | maxdiffCN('Vector'' i Vector ',A,B,r); 1766 | 1767 | r = r + 1; 1768 | A = rand(1,2500); 1769 | B = rand(1,2500); 1770 | maxdiffCN('Vector'' o Vector ',A,B,r); 1771 | 1772 | r = r + 1; 1773 | A = rand(1000,1); 1774 | B = rand(1000,1000); 1775 | maxdiffCN('Vector'' * Matrix ',A,B,r); 1776 | 1777 | r = r + 1; 1778 | A = rand(1000,1000); 1779 | B = rand(1000,1); 1780 | maxdiffCN('Matrix'' * Vector ',A,B,r); 1781 | 1782 | r = r + 1; 1783 | A = rand(1000,1000); 1784 | B = rand(1000,1000); 1785 | maxdiffCN('Matrix'' * Matrix ',A,B,r); 1786 | 1787 | %-------------------------------------------------------------------------- 1788 | disp(' '); 1789 | disp('(real)'' * (complex)'); 1790 | disp(' '); 1791 | 1792 | r = rsave; 1793 | 1794 | r = r + 1; 1795 | A = rand(1,1); 1796 | B = rand(1,10000) + rand(1,10000)*1i; 1797 | maxdiffCN('Scalar'' * Vector ',A,B,r); 1798 | 1799 | r = r + 1; 1800 | A = rand(10000,1); 1801 | B = rand(1,1) + rand(1,1)*1i; 1802 | maxdiffCN('Vector'' * Scalar ',A,B,r); 1803 | 1804 | r = r + 1; 1805 | A = rand(1,1); 1806 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 1807 | maxdiffCN('Scalar'' * Array ',A,B,r); 1808 | 1809 | r = r + 1; 1810 | A = rand(10000000,1); 1811 | B = rand(10000000,1) + rand(10000000,1)*1i; 1812 | maxdiffCN('Vector'' i Vector ',A,B,r); 1813 | 1814 | r = r + 1; 1815 | A = rand(1,2500); 1816 | B = rand(1,2500) + rand(1,2500)*1i; 1817 | maxdiffCN('Vector'' o Vector ',A,B,r); 1818 | 1819 | r = r + 1; 1820 | A = rand(1000,1); 1821 | B = rand(1000,1000) + rand(1000,1000)*1i; 1822 | maxdiffCN('Vector'' * Matrix ',A,B,r); 1823 | 1824 | r = r + 1; 1825 | A = rand(1000,1000); 1826 | B = rand(1000,1) + rand(1000,1)*1i; 1827 | maxdiffCN('Matrix'' * Vector ',A,B,r); 1828 | 1829 | r = r + 1; 1830 | A = rand(1000,1000); 1831 | B = rand(1000,1000) + rand(1000,1000)*1i; 1832 | maxdiffCN('Matrix'' * Matrix ',A,B,r); 1833 | 1834 | %-------------------------------------------------------------------------- 1835 | disp(' '); 1836 | disp('(complex)'' * (real)'); 1837 | disp(' '); 1838 | 1839 | r = rsave; 1840 | 1841 | r = r + 1; 1842 | A = rand(1,1) + rand(1,1)*1i; 1843 | B = rand(1,10000); 1844 | maxdiffCN('Scalar'' * Vector ',A,B,r); 1845 | 1846 | r = r + 1; 1847 | A = rand(10000,1)+ rand(10000,1)*1i; 1848 | B = rand(1,1); 1849 | maxdiffCN('Vector'' * Scalar ',A,B,r); 1850 | 1851 | r = r + 1; 1852 | A = rand(1,1) + rand(1,1)*1i; 1853 | B = rand(10,20,30,40); 1854 | maxdiffCN('Scalar'' * Array ',A,B,r); 1855 | 1856 | r = r + 1; 1857 | A = rand(10000000,1) + rand(10000000,1)*1i; 1858 | B = rand(10000000,1); 1859 | maxdiffCN('Vector'' i Vector ',A,B,r); 1860 | 1861 | r = r + 1; 1862 | A = rand(1,2500) + rand(1,2500)*1i; 1863 | B = rand(1,2500); 1864 | maxdiffCN('Vector'' o Vector ',A,B,r); 1865 | 1866 | r = r + 1; 1867 | A = rand(1000,1) + rand(1000,1)*1i; 1868 | B = rand(1000,1000); 1869 | maxdiffCN('Vector'' * Matrix ',A,B,r); 1870 | 1871 | r = r + 1; 1872 | A = rand(1000,1000) + rand(1000,1000)*1i; 1873 | B = rand(1000,1); 1874 | maxdiffCN('Matrix'' * Vector ',A,B,r); 1875 | 1876 | r = r + 1; 1877 | A = rand(1000,1000) + rand(1000,1000)*1i; 1878 | B = rand(1000,1000); 1879 | maxdiffCN('Matrix'' * Matrix ',A,B,r); 1880 | 1881 | %-------------------------------------------------------------------------- 1882 | disp(' '); 1883 | disp('(complex)'' * (complex)'); 1884 | disp(' '); 1885 | 1886 | r = rsave; 1887 | 1888 | r = r + 1; 1889 | A = rand(1,1) + rand(1,1)*1i; 1890 | B = rand(1,10000) + rand(1,10000)*1i; 1891 | maxdiffCN('Scalar'' * Vector ',A,B,r); 1892 | 1893 | r = r + 1; 1894 | A = rand(10000,1)+ rand(10000,1)*1i; 1895 | B = rand(1,1) + rand(1,1)*1i; 1896 | maxdiffCN('Vector'' * Scalar ',A,B,r); 1897 | 1898 | r = r + 1; 1899 | A = rand(1,1) + rand(1,1)*1i; 1900 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 1901 | maxdiffCN('Scalar'' * Array ',A,B,r); 1902 | 1903 | r = r + 1; 1904 | A = rand(10000000,1) + rand(10000000,1)*1i; 1905 | B = rand(10000000,1) + rand(10000000,1)*1i; 1906 | maxdiffCN('Vector'' i Vector ',A,B,r); 1907 | 1908 | r = r + 1; 1909 | A = rand(1,2500) + rand(1,2500)*1i; 1910 | B = rand(1,2500) + rand(1,2500)*1i; 1911 | maxdiffCN('Vector'' o Vector ',A,B,r); 1912 | 1913 | r = r + 1; 1914 | A = rand(1000,1) + rand(1000,1)*1i; 1915 | B = rand(1000,1000) + rand(1000,1000)*1i; 1916 | maxdiffCN('Vector'' * Matrix ',A,B,r); 1917 | 1918 | r = r + 1; 1919 | A = rand(1000,1000) + rand(1000,1000)*1i; 1920 | B = rand(1000,1) + rand(1000,1)*1i; 1921 | maxdiffCN('Matrix'' * Vector ',A,B,r); 1922 | 1923 | r = r + 1; 1924 | A = rand(1000,1000) + rand(1000,1000)*1i; 1925 | B = rand(1000,1000) + rand(1000,1000)*1i; 1926 | maxdiffCN('Matrix'' * Matrix ',A,B,r); 1927 | 1928 | running_time(datenum(clock) - start_time); 1929 | 1930 | %-------------------------------------------------------------------------- 1931 | %-------------------------------------------------------------------------- 1932 | 1933 | %end % debug jump 1934 | 1935 | disp('----------------------------------'); 1936 | disp(' '); 1937 | disp('Numerical Comparison Tests ...'); 1938 | disp(' '); 1939 | disp('(real)'' * (real).'''); 1940 | disp(' '); 1941 | 1942 | if( isequal([]'*[]',mtimesx([],'C',[],'C')) ) 1943 | disp('Empty'' * Empty.'' EQUAL'); 1944 | else 1945 | disp('Empty'' * Empty.'' NOT EQUAL <---'); 1946 | end 1947 | 1948 | r = r + 1; 1949 | mtimesx_dtable(r,:) = RC; 1950 | 1951 | rsave = r; 1952 | 1953 | r = r + 1; 1954 | A = rand(1,1); 1955 | B = rand(10000,1); 1956 | maxdiffCT('Scalar'' * Vector.'' ',A,B,r); 1957 | 1958 | r = r + 1; 1959 | A = rand(10000,1); 1960 | B = rand(1,1); 1961 | maxdiffCT('Vector'' * Scalar.'' ',A,B,r); 1962 | 1963 | r = r + 1; 1964 | A = rand(10000000,1); 1965 | B = rand(1,10000000); 1966 | maxdiffCT('Vector'' i Vector.'' ',A,B,r); 1967 | 1968 | r = r + 1; 1969 | A = rand(1,2500); 1970 | B = rand(2500,1); 1971 | maxdiffCT('Vector'' o Vector.'' ',A,B,r); 1972 | 1973 | r = r + 1; 1974 | A = rand(1000,1); 1975 | B = rand(1000,1000); 1976 | maxdiffCT('Vector'' * Matrix.'' ',A,B,r); 1977 | 1978 | r = r + 1; 1979 | A = rand(1000,1000); 1980 | B = rand(1,1000); 1981 | maxdiffCT('Matrix'' * Vector.'' ',A,B,r); 1982 | 1983 | r = r + 1; 1984 | A = rand(1000,1000); 1985 | B = rand(1000,1000); 1986 | maxdiffCT('Matrix'' * Matrix.'' ',A,B,r); 1987 | 1988 | %-------------------------------------------------------------------------- 1989 | disp(' '); 1990 | disp('(real)'' * (complex).'''); 1991 | disp(' '); 1992 | 1993 | r = rsave; 1994 | 1995 | r = r + 1; 1996 | A = rand(1,1); 1997 | B = rand(1,10000) + rand(1,10000)*1i; 1998 | maxdiffCT('Scalar'' * Vector.'' ',A,B,r); 1999 | 2000 | r = r + 1; 2001 | A = rand(10000,1); 2002 | B = rand(1,1) + rand(1,1)*1i; 2003 | maxdiffCT('Vector'' * Scalar.'' ',A,B,r); 2004 | 2005 | r = r + 1; 2006 | A = rand(10000000,1); 2007 | B = rand(1,10000000) + rand(1,10000000)*1i; 2008 | maxdiffCT('Vector'' i Vector.'' ',A,B,r); 2009 | 2010 | r = r + 1; 2011 | A = rand(1,2500); 2012 | B = rand(2500,1) + rand(2500,1)*1i; 2013 | maxdiffCT('Vector'' o Vector.'' ',A,B,r); 2014 | 2015 | r = r + 1; 2016 | A = rand(1000,1); 2017 | B = rand(1000,1000) + rand(1000,1000)*1i; 2018 | maxdiffCT('Vector'' * Matrix.'' ',A,B,r); 2019 | 2020 | r = r + 1; 2021 | A = rand(1000,1000); 2022 | B = rand(1,1000) + rand(1,1000)*1i; 2023 | maxdiffCT('Matrix'' * Vector.'' ',A,B,r); 2024 | 2025 | r = r + 1; 2026 | A = rand(1000,1000); 2027 | B = rand(1000,1000) + rand(1000,1000)*1i; 2028 | maxdiffCT('Matrix'' * Matrix.'' ',A,B,r); 2029 | 2030 | %-------------------------------------------------------------------------- 2031 | disp(' '); 2032 | disp('(complex)'' * (real).'''); 2033 | disp(' '); 2034 | 2035 | r = rsave; 2036 | 2037 | r = r + 1; 2038 | A = rand(1,1) + rand(1,1)*1i; 2039 | B = rand(1,10000); 2040 | maxdiffCT('Scalar'' * Vector.'' ',A,B,r); 2041 | 2042 | r = r + 1; 2043 | A = rand(10000,1)+ rand(10000,1)*1i; 2044 | B = rand(1,1); 2045 | maxdiffCT('Vector'' * Scalar.'' ',A,B,r); 2046 | 2047 | r = r + 1; 2048 | A = rand(10000000,1) + rand(10000000,1)*1i; 2049 | B = rand(1,10000000); 2050 | maxdiffCT('Vector'' i Vector.'' ',A,B,r); 2051 | 2052 | r = r + 1; 2053 | A = rand(1,2500) + rand(1,2500)*1i; 2054 | B = rand(2500,1); 2055 | maxdiffCT('Vector'' o Vector.'' ',A,B,r); 2056 | 2057 | r = r + 1; 2058 | A = rand(1000,1) + rand(1000,1)*1i; 2059 | B = rand(1000,1000); 2060 | maxdiffCT('Vector'' * Matrix.'' ',A,B,r); 2061 | 2062 | r = r + 1; 2063 | A = rand(1000,1000) + rand(1000,1000)*1i; 2064 | B = rand(1,1000); 2065 | maxdiffCT('Matrix'' * Vector.'' ',A,B,r); 2066 | 2067 | r = r + 1; 2068 | A = rand(1000,1000) + rand(1000,1000)*1i; 2069 | B = rand(1000,1000); 2070 | maxdiffCT('Matrix'' * Matrix.'' ',A,B,r); 2071 | 2072 | %-------------------------------------------------------------------------- 2073 | disp(' '); 2074 | disp('(complex)'' * (complex).'''); 2075 | disp(' '); 2076 | 2077 | r = rsave; 2078 | 2079 | r = r + 1; 2080 | A = rand(1,1) + rand(1,1)*1i; 2081 | B = rand(1,10000) + rand(1,10000)*1i; 2082 | maxdiffCT('Scalar'' * Vector.'' ',A,B,r); 2083 | 2084 | r = r + 1; 2085 | A = rand(10000,1)+ rand(10000,1)*1i; 2086 | B = rand(1,1) + rand(1,1)*1i; 2087 | maxdiffCT('Vector'' * Scalar.'' ',A,B,r); 2088 | 2089 | r = r + 1; 2090 | A = rand(10000000,1) + rand(10000000,1)*1i; 2091 | B = rand(1,10000000) + rand(1,10000000)*1i; 2092 | maxdiffCT('Vector'' i Vector.'' ',A,B,r); 2093 | 2094 | r = r + 1; 2095 | A = rand(1,2500) + rand(1,2500)*1i; 2096 | B = rand(2500,1) + rand(2500,1)*1i; 2097 | maxdiffCT('Vector'' o Vector.'' ',A,B,r); 2098 | 2099 | r = r + 1; 2100 | A = rand(1000,1) + rand(1000,1)*1i; 2101 | B = rand(1000,1000) + rand(1000,1000)*1i; 2102 | maxdiffCT('Vector'' * Matrix.'' ',A,B,r); 2103 | 2104 | r = r + 1; 2105 | A = rand(1000,1000) + rand(1000,1000)*1i; 2106 | B = rand(1,1000) + rand(1,1000)*1i; 2107 | maxdiffCT('Matrix'' * Vector.'' ',A,B,r); 2108 | 2109 | r = r + 1; 2110 | A = rand(1000,1000) + rand(1000,1000)*1i; 2111 | B = rand(1000,1000) + rand(1000,1000)*1i; 2112 | maxdiffCT('Matrix'' * Matrix.'' ',A,B,r); 2113 | 2114 | running_time(datenum(clock) - start_time); 2115 | 2116 | %-------------------------------------------------------------------------- 2117 | %-------------------------------------------------------------------------- 2118 | 2119 | %end % debug jump 2120 | 2121 | disp('----------------------------------'); 2122 | disp(' '); 2123 | disp('Numerical Comparison Tests ...'); 2124 | disp(' '); 2125 | disp('(real)'' * (real)'''); 2126 | disp(' '); 2127 | 2128 | if( isequal([]'*[]',mtimesx([],'C',[],'C')) ) 2129 | disp('Empty'' * Empty'' EQUAL'); 2130 | else 2131 | disp('Empty'' * Empty'' NOT EQUAL <---'); 2132 | end 2133 | 2134 | r = r + 1; 2135 | mtimesx_dtable(r,:) = RC; 2136 | 2137 | rsave = r; 2138 | 2139 | r = r + 1; 2140 | A = rand(1,1); 2141 | B = rand(10000,1); 2142 | maxdiffCC('Scalar'' * Vector'' ',A,B,r); 2143 | 2144 | r = r + 1; 2145 | A = rand(10000,1); 2146 | B = rand(1,1); 2147 | maxdiffCC('Vector'' * Scalar'' ',A,B,r); 2148 | 2149 | r = r + 1; 2150 | A = rand(10000000,1); 2151 | B = rand(1,10000000); 2152 | maxdiffCC('Vector'' i Vector'' ',A,B,r); 2153 | 2154 | r = r + 1; 2155 | A = rand(1,2500); 2156 | B = rand(2500,1); 2157 | maxdiffCC('Vector'' o Vector'' ',A,B,r); 2158 | 2159 | r = r + 1; 2160 | A = rand(1000,1); 2161 | B = rand(1000,1000); 2162 | maxdiffCC('Vector'' * Matrix'' ',A,B,r); 2163 | 2164 | r = r + 1; 2165 | A = rand(1000,1000); 2166 | B = rand(1,1000); 2167 | maxdiffCC('Matrix'' * Vector'' ',A,B,r); 2168 | 2169 | r = r + 1; 2170 | A = rand(1000,1000); 2171 | B = rand(1000,1000); 2172 | maxdiffCC('Matrix'' * Matrix'' ',A,B,r); 2173 | 2174 | %-------------------------------------------------------------------------- 2175 | disp(' '); 2176 | disp('(real)'' * (complex)'''); 2177 | disp(' '); 2178 | 2179 | r = rsave; 2180 | 2181 | r = r + 1; 2182 | A = rand(1,1); 2183 | B = rand(1,10000) + rand(1,10000)*1i; 2184 | maxdiffCC('Scalar'' * Vector'' ',A,B,r); 2185 | 2186 | r = r + 1; 2187 | A = rand(10000,1); 2188 | B = rand(1,1) + rand(1,1)*1i; 2189 | maxdiffCC('Vector'' * Scalar'' ',A,B,r); 2190 | 2191 | r = r + 1; 2192 | A = rand(10000000,1); 2193 | B = rand(1,10000000) + rand(1,10000000)*1i; 2194 | maxdiffCC('Vector'' i Vector'' ',A,B,r); 2195 | 2196 | r = r + 1; 2197 | A = rand(1,2500); 2198 | B = rand(2500,1) + rand(2500,1)*1i; 2199 | maxdiffCC('Vector'' o Vector'' ',A,B,r); 2200 | 2201 | r = r + 1; 2202 | A = rand(1000,1); 2203 | B = rand(1000,1000) + rand(1000,1000)*1i; 2204 | maxdiffCC('Vector'' * Matrix'' ',A,B,r); 2205 | 2206 | r = r + 1; 2207 | A = rand(1000,1000); 2208 | B = rand(1,1000) + rand(1,1000)*1i; 2209 | maxdiffCC('Matrix'' * Vector'' ',A,B,r); 2210 | 2211 | r = r + 1; 2212 | A = rand(1000,1000); 2213 | B = rand(1000,1000) + rand(1000,1000)*1i; 2214 | maxdiffCC('Matrix'' * Matrix'' ',A,B,r); 2215 | 2216 | %-------------------------------------------------------------------------- 2217 | disp(' '); 2218 | disp('(complex)'' * (real)'''); 2219 | disp(' '); 2220 | 2221 | r = rsave; 2222 | 2223 | r = r + 1; 2224 | A = rand(1,1) + rand(1,1)*1i; 2225 | B = rand(1,10000); 2226 | maxdiffCC('Scalar'' * Vector'' ',A,B,r); 2227 | 2228 | r = r + 1; 2229 | A = rand(10000,1)+ rand(10000,1)*1i; 2230 | B = rand(1,1); 2231 | maxdiffCC('Vector'' * Scalar'' ',A,B,r); 2232 | 2233 | r = r + 1; 2234 | A = rand(10000000,1) + rand(10000000,1)*1i; 2235 | B = rand(1,10000000); 2236 | maxdiffCC('Vector'' i Vector'' ',A,B,r); 2237 | 2238 | r = r + 1; 2239 | A = rand(1,2500) + rand(1,2500)*1i; 2240 | B = rand(2500,1); 2241 | maxdiffCC('Vector'' o Vector'' ',A,B,r); 2242 | 2243 | r = r + 1; 2244 | A = rand(1000,1) + rand(1000,1)*1i; 2245 | B = rand(1000,1000); 2246 | maxdiffCC('Vector'' * Matrix'' ',A,B,r); 2247 | 2248 | r = r + 1; 2249 | A = rand(1000,1000) + rand(1000,1000)*1i; 2250 | B = rand(1,1000); 2251 | maxdiffCC('Matrix'' * Vector'' ',A,B,r); 2252 | 2253 | r = r + 1; 2254 | A = rand(1000,1000) + rand(1000,1000)*1i; 2255 | B = rand(1000,1000); 2256 | maxdiffCC('Matrix'' * Matrix'' ',A,B,r); 2257 | 2258 | %-------------------------------------------------------------------------- 2259 | disp(' '); 2260 | disp('(complex)'' * (complex)'''); 2261 | disp(' '); 2262 | 2263 | r = rsave; 2264 | 2265 | r = r + 1; 2266 | A = rand(1,1) + rand(1,1)*1i; 2267 | B = rand(1,10000) + rand(1,10000)*1i; 2268 | maxdiffCC('Scalar'' * Vector'' ',A,B,r); 2269 | 2270 | r = r + 1; 2271 | A = rand(10000,1)+ rand(10000,1)*1i; 2272 | B = rand(1,1) + rand(1,1)*1i; 2273 | maxdiffCC('Vector'' * Scalar'' ',A,B,r); 2274 | 2275 | r = r + 1; 2276 | A = rand(10000000,1) + rand(10000000,1)*1i; 2277 | B = rand(1,10000000) + rand(1,10000000)*1i; 2278 | maxdiffCC('Vector'' i Vector'' ',A,B,r); 2279 | 2280 | r = r + 1; 2281 | A = rand(1,2500) + rand(1,2500)*1i; 2282 | B = rand(2500,1) + rand(2500,1)*1i; 2283 | maxdiffCC('Vector'' o Vector'' ',A,B,r); 2284 | 2285 | r = r + 1; 2286 | A = rand(1000,1) + rand(1000,1)*1i; 2287 | B = rand(1000,1000) + rand(1000,1000)*1i; 2288 | maxdiffCC('Vector'' * Matrix'' ',A,B,r); 2289 | 2290 | r = r + 1; 2291 | A = rand(1000,1000) + rand(1000,1000)*1i; 2292 | B = rand(1,1000) + rand(1,1000)*1i; 2293 | maxdiffCC('Matrix'' * Vector'' ',A,B,r); 2294 | 2295 | r = r + 1; 2296 | A = rand(1000,1000) + rand(1000,1000)*1i; 2297 | B = rand(1000,1000) + rand(1000,1000)*1i; 2298 | maxdiffCC('Matrix'' * Matrix'' ',A,B,r); 2299 | 2300 | running_time(datenum(clock) - start_time); 2301 | 2302 | %-------------------------------------------------------------------------- 2303 | %-------------------------------------------------------------------------- 2304 | 2305 | disp('----------------------------------'); 2306 | disp(' '); 2307 | disp('Numerical Comparison Tests ...'); 2308 | disp(' '); 2309 | disp('(real)'' * conj(real)'); 2310 | disp(' '); 2311 | 2312 | if( isequal([]'*conj([]),mtimesx([],'C',[],'G')) ) 2313 | disp('Empty'' * conj(Empty) EQUAL'); 2314 | else 2315 | disp('Empty'' * conj(Empty) NOT EQUAL <---'); 2316 | end 2317 | 2318 | r = r + 1; 2319 | mtimesx_dtable(r,:) = RC; 2320 | 2321 | rsave = r; 2322 | 2323 | r = r + 1; 2324 | A = rand(1,1); 2325 | B = rand(1,10000); 2326 | maxdiffCG('Scalar'' * conj(Vector) ',A,B,r); 2327 | 2328 | r = r + 1; 2329 | A = rand(10000,1); 2330 | B = rand(1,1); 2331 | maxdiffCG('Vector'' * conj(Scalar) ',A,B,r); 2332 | 2333 | r = r + 1; 2334 | A = rand(1,1); 2335 | B = rand(10,20,30,40); 2336 | maxdiffCG('Scalar'' * conj(Array) ',A,B,r); 2337 | 2338 | r = r + 1; 2339 | A = rand(10000000,1); 2340 | B = rand(10000000,1); 2341 | maxdiffCG('Vector'' i conj(Vector) ',A,B,r); 2342 | 2343 | r = r + 1; 2344 | A = rand(1,2500); 2345 | B = rand(1,2500); 2346 | maxdiffCG('Vector'' o conj(Vector) ',A,B,r); 2347 | 2348 | r = r + 1; 2349 | A = rand(1000,1); 2350 | B = rand(1000,1000); 2351 | maxdiffCG('Vector'' * conj(Matrix) ',A,B,r); 2352 | 2353 | r = r + 1; 2354 | A = rand(1000,1000); 2355 | B = rand(1000,1); 2356 | maxdiffCG('Matrix'' * conj(Vector) ',A,B,r); 2357 | 2358 | r = r + 1; 2359 | A = rand(1000,1000); 2360 | B = rand(1000,1000); 2361 | maxdiffCG('Matrix'' * conj(Matrix) ',A,B,r); 2362 | 2363 | %-------------------------------------------------------------------------- 2364 | disp(' '); 2365 | disp('(real)'' * conj(complex)'); 2366 | disp(' '); 2367 | 2368 | r = rsave; 2369 | 2370 | r = r + 1; 2371 | A = rand(1,1); 2372 | B = rand(1,10000) + rand(1,10000)*1i; 2373 | maxdiffCG('Scalar'' * conj(Vector) ',A,B,r); 2374 | 2375 | r = r + 1; 2376 | A = rand(10000,1); 2377 | B = rand(1,1) + rand(1,1)*1i; 2378 | maxdiffCG('Vector'' * conj(Scalar) ',A,B,r); 2379 | 2380 | r = r + 1; 2381 | A = rand(1,1); 2382 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2383 | maxdiffCG('Scalar'' * conj(Array) ',A,B,r); 2384 | 2385 | r = r + 1; 2386 | A = rand(10000000,1); 2387 | B = rand(10000000,1) + rand(10000000,1)*1i; 2388 | maxdiffCG('Vector'' i conj(Vector) ',A,B,r); 2389 | 2390 | r = r + 1; 2391 | A = rand(1,2500); 2392 | B = rand(1,2500) + rand(1,2500)*1i; 2393 | maxdiffCG('Vector'' o conj(Vector) ',A,B,r); 2394 | 2395 | r = r + 1; 2396 | A = rand(1000,1); 2397 | B = rand(1000,1000) + rand(1000,1000)*1i; 2398 | maxdiffCG('Vector'' * conj(Matrix) ',A,B,r); 2399 | 2400 | r = r + 1; 2401 | A = rand(1000,1000); 2402 | B = rand(1000,1) + rand(1000,1)*1i; 2403 | maxdiffCG('Matrix'' * conj(Vector) ',A,B,r); 2404 | 2405 | r = r + 1; 2406 | A = rand(1000,1000); 2407 | B = rand(1000,1000) + rand(1000,1000)*1i; 2408 | maxdiffCG('Matrix'' * conj(Matrix) ',A,B,r); 2409 | 2410 | %-------------------------------------------------------------------------- 2411 | disp(' '); 2412 | disp('(complex)'' * conj(real)'); 2413 | disp(' '); 2414 | 2415 | r = rsave; 2416 | 2417 | r = r + 1; 2418 | A = rand(1,1) + rand(1,1)*1i; 2419 | B = rand(1,10000); 2420 | maxdiffCG('Scalar'' * conj(Vector) ',A,B,r); 2421 | 2422 | r = r + 1; 2423 | A = rand(10000,1)+ rand(10000,1)*1i; 2424 | B = rand(1,1); 2425 | maxdiffCG('Vector'' * conj(Scalar) ',A,B,r); 2426 | 2427 | r = r + 1; 2428 | A = rand(1,1) + rand(1,1)*1i; 2429 | B = rand(10,20,30,40); 2430 | maxdiffCG('Scalar'' * conj(Array) ',A,B,r); 2431 | 2432 | r = r + 1; 2433 | A = rand(10000000,1) + rand(10000000,1)*1i; 2434 | B = rand(10000000,1); 2435 | maxdiffCG('Vector'' i conj(Vector) ',A,B,r); 2436 | 2437 | r = r + 1; 2438 | A = rand(1,2500) + rand(1,2500)*1i; 2439 | B = rand(1,2500); 2440 | maxdiffCG('Vector'' o conj(Vector) ',A,B,r); 2441 | 2442 | r = r + 1; 2443 | A = rand(1000,1) + rand(1000,1)*1i; 2444 | B = rand(1000,1000); 2445 | maxdiffCG('Vector'' * conj(Matrix) ',A,B,r); 2446 | 2447 | r = r + 1; 2448 | A = rand(1000,1000) + rand(1000,1000)*1i; 2449 | B = rand(1000,1); 2450 | maxdiffCG('Matrix'' * conj(Vector) ',A,B,r); 2451 | 2452 | r = r + 1; 2453 | A = rand(1000,1000) + rand(1000,1000)*1i; 2454 | B = rand(1000,1000); 2455 | maxdiffCG('Matrix'' * conj(Matrix) ',A,B,r); 2456 | 2457 | %-------------------------------------------------------------------------- 2458 | disp(' '); 2459 | disp('(complex)'' * conj(complex)'); 2460 | disp(' '); 2461 | 2462 | r = rsave; 2463 | 2464 | r = r + 1; 2465 | A = rand(1,1) + rand(1,1)*1i; 2466 | B = rand(1,10000) + rand(1,10000)*1i; 2467 | maxdiffCG('Scalar'' * conj(Vector) ',A,B,r); 2468 | 2469 | r = r + 1; 2470 | A = rand(10000,1)+ rand(10000,1)*1i; 2471 | B = rand(1,1) + rand(1,1)*1i; 2472 | maxdiffCG('Vector'' * conj(Scalar) ',A,B,r); 2473 | 2474 | r = r + 1; 2475 | A = rand(1,1) + rand(1,1)*1i; 2476 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2477 | maxdiffCG('Scalar'' * conj(Array) ',A,B,r); 2478 | 2479 | r = r + 1; 2480 | A = rand(10000000,1) + rand(10000000,1)*1i; 2481 | B = rand(10000000,1) + rand(10000000,1)*1i; 2482 | maxdiffCG('Vector'' i conj(Vector) ',A,B,r); 2483 | 2484 | r = r + 1; 2485 | A = rand(1,2500) + rand(1,2500)*1i; 2486 | B = rand(1,2500) + rand(1,2500)*1i; 2487 | maxdiffCG('Vector'' o conj(Vector) ',A,B,r); 2488 | 2489 | r = r + 1; 2490 | A = rand(1000,1) + rand(1000,1)*1i; 2491 | B = rand(1000,1000) + rand(1000,1000)*1i; 2492 | maxdiffCG('Vector'' * conj(Matrix) ',A,B,r); 2493 | 2494 | r = r + 1; 2495 | A = rand(1000,1000) + rand(1000,1000)*1i; 2496 | B = rand(1000,1) + rand(1000,1)*1i; 2497 | maxdiffCG('Matrix'' * conj(Vector) ',A,B,r); 2498 | 2499 | r = r + 1; 2500 | A = rand(1000,1000) + rand(1000,1000)*1i; 2501 | B = rand(1000,1000) + rand(1000,1000)*1i; 2502 | maxdiffCG('Matrix'' * conj(Matrix) ',A,B,r); 2503 | 2504 | running_time(datenum(clock) - start_time); 2505 | 2506 | %-------------------------------------------------------------------------- 2507 | %-------------------------------------------------------------------------- 2508 | 2509 | %end % debug jump 2510 | 2511 | disp(' '); 2512 | disp('Numerical Comparison Tests ...'); 2513 | disp(' '); 2514 | disp('conj(real) * (real)'); 2515 | disp(' '); 2516 | 2517 | if( isequal(conj([])*[],mtimesx([],'G',[])) ) 2518 | disp('conj(Empty) * Empty EQUAL'); 2519 | else 2520 | disp('conj(Empty) * Empty NOT EQUAL <---'); 2521 | end 2522 | 2523 | r = r + 1; 2524 | mtimesx_dtable(r,:) = RC; 2525 | 2526 | r = rsave; 2527 | 2528 | r = r + 1; 2529 | A = rand(1,1); 2530 | B = rand(1,10000); 2531 | maxdiffGN('conj(Scalar) * Vector ',A,B,r); 2532 | 2533 | r = r + 1; 2534 | A = rand(1,10000); 2535 | B = rand(1,1); 2536 | maxdiffGN('conj(Vector) * Scalar ',A,B,r); 2537 | 2538 | r = r + 1; 2539 | A = rand(1,1); 2540 | B = rand(10,20,30,40); 2541 | maxdiffGN('conj(Scalar) * Array ',A,B,r); 2542 | 2543 | r = r + 1; 2544 | A = rand(10,20,30,40); 2545 | B = rand(1,1); 2546 | maxdiffGN('conj(Array) * Scalar ',A,B,r); 2547 | 2548 | r = r + 1; 2549 | A = rand(1,10000000); 2550 | B = rand(10000000,1); 2551 | maxdiffGN('conj(Vector) i Vector ',A,B,r); 2552 | 2553 | r = r + 1; 2554 | A = rand(2500,1); 2555 | B = rand(1,2500); 2556 | maxdiffGN('conj(Vector) o Vector ',A,B,r); 2557 | 2558 | r = r + 1; 2559 | A = rand(1,1000); 2560 | B = rand(1000,1000); 2561 | maxdiffGN('conj(Vector) * Matrix ',A,B,r); 2562 | 2563 | r = r + 1; 2564 | A = rand(1000,1000); 2565 | B = rand(1000,1); 2566 | maxdiffGN('conj(Matrix) * Vector ',A,B,r); 2567 | 2568 | r = r + 1; 2569 | A = rand(1000,1000); 2570 | B = rand(1000,1000); 2571 | maxdiffGN('conj(Matrix) * Matrix ',A,B,r); 2572 | 2573 | %-------------------------------------------------------------------------- 2574 | disp(' '); 2575 | disp('conj(real) * (complex)'); 2576 | disp(' '); 2577 | 2578 | r = rsave; 2579 | 2580 | r = r + 1; 2581 | A = rand(1,1); 2582 | B = rand(1,10000) + rand(1,10000)*1i; 2583 | maxdiffGN('conj(Scalar) * Vector ',A,B,r); 2584 | 2585 | r = r + 1; 2586 | A = rand(1,10000); 2587 | B = rand(1,1) + rand(1,1)*1i; 2588 | maxdiffGN('conj(Vector) * Scalar ',A,B,r); 2589 | 2590 | r = r + 1; 2591 | A = rand(1,1); 2592 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2593 | maxdiffGN('conj(Scalar) * Array ',A,B,r); 2594 | 2595 | r = r + 1; 2596 | A = rand(10,20,30,40); 2597 | B = rand(1,1) + rand(1,1)*1i; 2598 | maxdiffGN('conj(Array) * Scalar ',A,B,r); 2599 | 2600 | r = r + 1; 2601 | A = rand(1,10000000); 2602 | B = rand(10000000,1) + rand(10000000,1)*1i; 2603 | maxdiffGN('conj(Vector) i Vector ',A,B,r); 2604 | 2605 | r = r + 1; 2606 | A = rand(2500,1); 2607 | B = rand(1,2500) + rand(1,2500)*1i; 2608 | maxdiffGN('conj(Vector) o Vector ',A,B,r); 2609 | 2610 | r = r + 1; 2611 | A = rand(1,1000); 2612 | B = rand(1000,1000) + rand(1000,1000)*1i; 2613 | maxdiffGN('conj(Vector) * Matrix ',A,B,r); 2614 | 2615 | r = r + 1; 2616 | A = rand(1000,1000); 2617 | B = rand(1000,1) + rand(1000,1)*1i; 2618 | maxdiffGN('conj(Matrix) * Vector ',A,B,r); 2619 | 2620 | r = r + 1; 2621 | A = rand(1000,1000); 2622 | B = rand(1000,1000) + rand(1000,1000)*1i; 2623 | maxdiffGN('conj(Matrix) * Matrix ',A,B,r); 2624 | 2625 | %-------------------------------------------------------------------------- 2626 | disp(' '); 2627 | disp('conj(complex)* (real)'); 2628 | disp(' '); 2629 | 2630 | r = rsave; 2631 | 2632 | r = r + 1; 2633 | A = rand(1,1) + rand(1,1)*1i; 2634 | B = rand(1,10000); 2635 | maxdiffGN('conj(Scalar) * Vector ',A,B,r); 2636 | 2637 | r = r + 1; 2638 | A = rand(1,10000)+ rand(1,10000)*1i; 2639 | B = rand(1,1); 2640 | maxdiffGN('conj(Vector) * Scalar ',A,B,r); 2641 | 2642 | r = r + 1; 2643 | A = rand(1,1) + rand(1,1)*1i; 2644 | B = rand(10,20,30,40); 2645 | maxdiffGN('conj(Scalar) * Array ',A,B,r); 2646 | 2647 | r = r + 1; 2648 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2649 | B = rand(1,1); 2650 | maxdiffGN('conj(Array) * Scalar ',A,B,r); 2651 | 2652 | r = r + 1; 2653 | A = rand(1,10000000) + rand(1,10000000)*1i; 2654 | B = rand(10000000,1); 2655 | maxdiffGN('conj(Vector) i Vector ',A,B,r); 2656 | 2657 | r = r + 1; 2658 | A = rand(2500,1) + rand(2500,1)*1i; 2659 | B = rand(1,2500); 2660 | maxdiffGN('conj(Vector) o Vector ',A,B,r); 2661 | 2662 | r = r + 1; 2663 | A = rand(1,1000) + rand(1,1000)*1i; 2664 | B = rand(1000,1000); 2665 | maxdiffGN('conj(Vector) * Matrix ',A,B,r); 2666 | 2667 | r = r + 1; 2668 | A = rand(1000,1000) + rand(1000,1000)*1i; 2669 | B = rand(1000,1); 2670 | maxdiffGN('conj(Matrix) * Vector ',A,B,r); 2671 | 2672 | r = r + 1; 2673 | A = rand(1000,1000) + rand(1000,1000)*1i; 2674 | B = rand(1000,1000); 2675 | maxdiffGN('conj(Matrix) * Matrix ',A,B,r); 2676 | 2677 | %-------------------------------------------------------------------------- 2678 | disp(' '); 2679 | disp('conj(complex)* (complex)'); 2680 | disp(' '); 2681 | 2682 | r = rsave; 2683 | 2684 | r = r + 1; 2685 | A = rand(1,1) + rand(1,1)*1i; 2686 | B = rand(1,10000) + rand(1,10000)*1i; 2687 | maxdiffGN('conj(Scalar) * Vector ',A,B,r); 2688 | 2689 | r = r + 1; 2690 | A = rand(1,10000)+ rand(1,10000)*1i; 2691 | B = rand(1,1) + rand(1,1)*1i; 2692 | maxdiffGN('conj(Vector) * Scalar ',A,B,r); 2693 | 2694 | r = r + 1; 2695 | A = rand(1,1) + rand(1,1)*1i; 2696 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2697 | maxdiffGN('conj(Scalar) * Array ',A,B,r); 2698 | 2699 | r = r + 1; 2700 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2701 | B = rand(1,1) + rand(1,1)*1i; 2702 | maxdiffGN('conj(Array) * Scalar ',A,B,r); 2703 | 2704 | r = r + 1; 2705 | A = rand(1,10000000) + rand(1,10000000)*1i; 2706 | B = rand(10000000,1) + rand(10000000,1)*1i; 2707 | maxdiffGN('conj(Vector) i Vector ',A,B,r); 2708 | 2709 | r = r + 1; 2710 | A = rand(2500,1) + rand(2500,1)*1i; 2711 | B = rand(1,2500) + rand(1,2500)*1i; 2712 | maxdiffGN('conj(Vector) o Vector ',A,B,r); 2713 | 2714 | r = r + 1; 2715 | A = rand(1,1000) + rand(1,1000)*1i; 2716 | B = rand(1000,1000) + rand(1000,1000)*1i; 2717 | maxdiffGN('conj(Vector) * Matrix ',A,B,r); 2718 | 2719 | r = r + 1; 2720 | A = rand(1000,1000) + rand(1000,1000)*1i; 2721 | B = rand(1000,1) + rand(1000,1)*1i; 2722 | maxdiffGN('conj(Matrix) * Vector ',A,B,r); 2723 | 2724 | r = r + 1; 2725 | A = rand(1000,1000) + rand(1000,1000)*1i; 2726 | B = rand(1000,1000) + rand(1000,1000)*1i; 2727 | maxdiffGN('conj(Matrix) * Matrix ',A,B,r); 2728 | 2729 | running_time(datenum(clock) - start_time); 2730 | 2731 | %-------------------------------------------------------------------------- 2732 | %-------------------------------------------------------------------------- 2733 | 2734 | %end % debug jump 2735 | 2736 | disp('----------------------------------'); 2737 | disp(' '); 2738 | disp('Numerical Comparison Tests ...'); 2739 | disp(' '); 2740 | disp('conj(real) * (real).'''); 2741 | disp(' '); 2742 | 2743 | if( isequal(conj([])*[].',mtimesx([],'G',[],'T')) ) 2744 | disp('conj(Empty) * Empty.'' EQUAL'); 2745 | else 2746 | disp('conj(Empty) * Empty.'' NOT EQUAL <---'); 2747 | end 2748 | 2749 | r = r + 1; 2750 | mtimesx_dtable(r,:) = RC; 2751 | 2752 | rsave = r; 2753 | 2754 | r = r + 1; 2755 | A = rand(1,1); 2756 | B = rand(10000,1); 2757 | maxdiffGT('conj(Scalar) * Vector.'' ',A,B,r); 2758 | 2759 | r = r + 1; 2760 | A = rand(10000,1); 2761 | B = rand(1,1); 2762 | maxdiffGT('conj(Vector) * Scalar.'' ',A,B,r); 2763 | 2764 | r = r + 1; 2765 | A = rand(10,20,30,40); 2766 | B = rand(1,1); 2767 | maxdiffGT('conj(Array) * Scalar.'' ',A,B,r); 2768 | 2769 | r = r + 1; 2770 | A = rand(1,10000000); 2771 | B = rand(1,10000000); 2772 | maxdiffGT('conj(Vector) i Vector.'' ',A,B,r); 2773 | 2774 | r = r + 1; 2775 | A = rand(2500,1); 2776 | B = rand(2500,1); 2777 | maxdiffGT('conj(Vector) o Vector.'' ',A,B,r); 2778 | 2779 | r = r + 1; 2780 | A = rand(1,1000); 2781 | B = rand(1000,1000); 2782 | maxdiffGT('conj(Vector) * Matrix.'' ',A,B,r); 2783 | 2784 | r = r + 1; 2785 | A = rand(1000,1000); 2786 | B = rand(1,1000); 2787 | maxdiffGT('conj(Matrix) * Vector.'' ',A,B,r); 2788 | 2789 | r = r + 1; 2790 | A = rand(1000,1000); 2791 | B = rand(1000,1000); 2792 | maxdiffGT('conj(Matrix) * Matrix.'' ',A,B,r); 2793 | 2794 | %-------------------------------------------------------------------------- 2795 | disp(' '); 2796 | disp('conj(real) * (complex).'''); 2797 | disp(' '); 2798 | 2799 | r = rsave; 2800 | 2801 | r = r + 1; 2802 | A = rand(1,1); 2803 | B = rand(1,10000) + rand(1,10000)*1i; 2804 | maxdiffGT('conj(Scalar) * Vector.'' ',A,B,r); 2805 | 2806 | r = r + 1; 2807 | A = rand(10000,1); 2808 | B = rand(1,1) + rand(1,1)*1i; 2809 | maxdiffGT('conj(Vector) * Scalar.'' ',A,B,r); 2810 | 2811 | r = r + 1; 2812 | A = rand(10,20,30,40); 2813 | B = rand(1,1) + rand(1,1)*1i; 2814 | maxdiffGT('conj(Array) * Scalar.'' ',A,B,r); 2815 | 2816 | r = r + 1; 2817 | A = rand(1,10000000); 2818 | B = rand(1,10000000) + rand(1,10000000)*1i; 2819 | maxdiffGT('conj(Vector) i Vector.'' ',A,B,r); 2820 | 2821 | r = r + 1; 2822 | A = rand(2500,1); 2823 | B = rand(2500,1) + rand(2500,1)*1i; 2824 | maxdiffGT('conj(Vector) o Vector.'' ',A,B,r); 2825 | 2826 | r = r + 1; 2827 | A = rand(1,1000); 2828 | B = rand(1000,1000) + rand(1000,1000)*1i; 2829 | maxdiffGT('conj(Vector) * Matrix.'' ',A,B,r); 2830 | 2831 | r = r + 1; 2832 | A = rand(1000,1000); 2833 | B = rand(1,1000) + rand(1,1000)*1i; 2834 | maxdiffGT('conj(Matrix) * Vector.'' ',A,B,r); 2835 | 2836 | r = r + 1; 2837 | A = rand(1000,1000); 2838 | B = rand(1000,1000) + rand(1000,1000)*1i; 2839 | maxdiffGT('conj(Matrix) * Matrix.'' ',A,B,r); 2840 | 2841 | %-------------------------------------------------------------------------- 2842 | disp(' '); 2843 | disp('conj(complex) * (real).'''); 2844 | disp(' '); 2845 | 2846 | r = rsave; 2847 | 2848 | r = r + 1; 2849 | A = rand(1,1) + rand(1,1)*1i; 2850 | B = rand(1,10000); 2851 | maxdiffGT('conj(Scalar) * Vector.'' ',A,B,r); 2852 | 2853 | r = r + 1; 2854 | A = rand(10000,1)+ rand(10000,1)*1i; 2855 | B = rand(1,1); 2856 | maxdiffGT('conj(Vector) * Scalar.'' ',A,B,r); 2857 | 2858 | r = r + 1; 2859 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2860 | B = rand(1,1); 2861 | maxdiffGT('conj(Array) * Scalar.'' ',A,B,r); 2862 | 2863 | r = r + 1; 2864 | A = rand(1,10000000) + rand(1,10000000)*1i; 2865 | B = rand(1,10000000); 2866 | maxdiffGT('conj(Vector) i Vector.'' ',A,B,r); 2867 | 2868 | r = r + 1; 2869 | A = rand(2500,1) + rand(2500,1)*1i; 2870 | B = rand(2500,1); 2871 | maxdiffGT('conj(Vector) o Vector.'' ',A,B,r); 2872 | 2873 | r = r + 1; 2874 | A = rand(1,1000) + rand(1,1000)*1i; 2875 | B = rand(1000,1000); 2876 | maxdiffGT('conj(Vector) * Matrix.'' ',A,B,r); 2877 | 2878 | r = r + 1; 2879 | A = rand(1000,1000) + rand(1000,1000)*1i; 2880 | B = rand(1,1000); 2881 | maxdiffGT('conj(Matrix) * Vector.'' ',A,B,r); 2882 | 2883 | r = r + 1; 2884 | A = rand(1000,1000) + rand(1000,1000)*1i; 2885 | B = rand(1000,1000); 2886 | maxdiffGT('conj(Matrix) * Matrix.'' ',A,B,r); 2887 | 2888 | %-------------------------------------------------------------------------- 2889 | disp(' '); 2890 | disp('conj(complex) * (complex).'''); 2891 | disp(' '); 2892 | 2893 | r = rsave; 2894 | 2895 | r = r + 1; 2896 | A = rand(1,1) + rand(1,1)*1i; 2897 | B = rand(1,10000) + rand(1,10000)*1i; 2898 | maxdiffGT('conj(Scalar) * Vector.'' ',A,B,r); 2899 | 2900 | r = r + 1; 2901 | A = rand(10000,1)+ rand(10000,1)*1i; 2902 | B = rand(1,1) + rand(1,1)*1i; 2903 | maxdiffGT('conj(Vector) * Scalar.'' ',A,B,r); 2904 | 2905 | r = r + 1; 2906 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 2907 | B = rand(1,1) + rand(1,1)*1i; 2908 | maxdiffGT('conj(Array) * Scalar.'' ',A,B,r); 2909 | 2910 | r = r + 1; 2911 | A = rand(1,10000000) + rand(1,10000000)*1i; 2912 | B = rand(1,10000000) + rand(1,10000000)*1i; 2913 | maxdiffGT('conj(Vector) i Vector.'' ',A,B,r); 2914 | 2915 | r = r + 1; 2916 | A = rand(2500,1) + rand(2500,1)*1i; 2917 | B = rand(2500,1) + rand(2500,1)*1i; 2918 | maxdiffGT('conj(Vector) o Vector.'' ',A,B,r); 2919 | 2920 | r = r + 1; 2921 | A = rand(1,1000) + rand(1,1000)*1i; 2922 | B = rand(1000,1000) + rand(1000,1000)*1i; 2923 | maxdiffGT('conj(Vector) * Matrix.'' ',A,B,r); 2924 | 2925 | r = r + 1; 2926 | A = rand(1000,1000) + rand(1000,1000)*1i; 2927 | B = rand(1,1000) + rand(1,1000)*1i; 2928 | maxdiffGT('conj(Matrix) * Vector.'' ',A,B,r); 2929 | 2930 | r = r + 1; 2931 | A = rand(1000,1000) + rand(1000,1000)*1i; 2932 | B = rand(1000,1000) + rand(1000,1000)*1i; 2933 | maxdiffGT('conj(Matrix) * Matrix.'' ',A,B,r); 2934 | 2935 | running_time(datenum(clock) - start_time); 2936 | 2937 | %-------------------------------------------------------------------------- 2938 | %-------------------------------------------------------------------------- 2939 | 2940 | %end % debug jump 2941 | 2942 | disp('----------------------------------'); 2943 | disp(' '); 2944 | disp('Numerical Comparison Tests ...'); 2945 | disp(' '); 2946 | disp('conj(real) * (real)'''); 2947 | disp(' '); 2948 | 2949 | if( isequal(conj([])*[]',mtimesx([],'G',[],'C')) ) 2950 | disp('conj(Empty) * Empty'' EQUAL'); 2951 | else 2952 | disp('conj(Empty) * Empty'' NOT EQUAL <---'); 2953 | end 2954 | 2955 | r = r + 1; 2956 | mtimesx_dtable(r,:) = RC; 2957 | 2958 | rsave = r; 2959 | 2960 | r = r + 1; 2961 | A = rand(1,1); 2962 | B = rand(10000,1); 2963 | maxdiffGC('conj(Scalar) * Vector'' ',A,B,r); 2964 | 2965 | r = r + 1; 2966 | A = rand(10000,1); 2967 | B = rand(1,1); 2968 | maxdiffGC('conj(Vector) * Scalar'' ',A,B,r); 2969 | 2970 | r = r + 1; 2971 | A = rand(10,20,30,40); 2972 | B = rand(1,1); 2973 | maxdiffGC('conj(Array) * Scalar'' ',A,B,r); 2974 | 2975 | r = r + 1; 2976 | A = rand(1,10000000); 2977 | B = rand(1,10000000); 2978 | maxdiffGC('conj(Vector) i Vector'' ',A,B,r); 2979 | 2980 | r = r + 1; 2981 | A = rand(2500,1); 2982 | B = rand(2500,1); 2983 | maxdiffGC('conj(Vector) o Vector'' ',A,B,r); 2984 | 2985 | r = r + 1; 2986 | A = rand(1,1000); 2987 | B = rand(1000,1000); 2988 | maxdiffGC('conj(Vector) * Matrix'' ',A,B,r); 2989 | 2990 | r = r + 1; 2991 | A = rand(1000,1000); 2992 | B = rand(1,1000); 2993 | maxdiffGC('conj(Matrix) * Vector'' ',A,B,r); 2994 | 2995 | r = r + 1; 2996 | A = rand(1000,1000); 2997 | B = rand(1000,1000); 2998 | maxdiffGC('conj(Matrix) * Matrix'' ',A,B,r); 2999 | 3000 | %-------------------------------------------------------------------------- 3001 | disp(' '); 3002 | disp('conj(real) * (complex)'''); 3003 | disp(' '); 3004 | 3005 | r = rsave; 3006 | 3007 | r = r + 1; 3008 | A = rand(1,1); 3009 | B = rand(1,10000) + rand(1,10000)*1i; 3010 | maxdiffGC('conj(Scalar) * Vector'' ',A,B,r); 3011 | 3012 | r = r + 1; 3013 | A = rand(10000,1); 3014 | B = rand(1,1) + rand(1,1)*1i; 3015 | maxdiffGC('conj(Vector) * Scalar'' ',A,B,r); 3016 | 3017 | r = r + 1; 3018 | A = rand(10,20,30,40); 3019 | B = rand(1,1) + rand(1,1)*1i; 3020 | maxdiffGC('conj(Array) * Scalar'' ',A,B,r); 3021 | 3022 | r = r + 1; 3023 | A = rand(1,10000000); 3024 | B = rand(1,10000000) + rand(1,10000000)*1i; 3025 | maxdiffGC('conj(Vector) i Vector'' ',A,B,r); 3026 | 3027 | r = r + 1; 3028 | A = rand(2500,1); 3029 | B = rand(2500,1) + rand(2500,1)*1i; 3030 | maxdiffGC('conj(Vector) o Vector'' ',A,B,r); 3031 | 3032 | r = r + 1; 3033 | A = rand(1,1000); 3034 | B = rand(1000,1000) + rand(1000,1000)*1i; 3035 | maxdiffGC('conj(Vector) * Matrix'' ',A,B,r); 3036 | 3037 | r = r + 1; 3038 | A = rand(1000,1000); 3039 | B = rand(1,1000) + rand(1,1000)*1i; 3040 | maxdiffGC('conj(Matrix) * Vector'' ',A,B,r); 3041 | 3042 | r = r + 1; 3043 | A = rand(1000,1000); 3044 | B = rand(1000,1000) + rand(1000,1000)*1i; 3045 | maxdiffGC('conj(Matrix) * Matrix'' ',A,B,r); 3046 | 3047 | %-------------------------------------------------------------------------- 3048 | disp(' '); 3049 | disp('conj(complex) * (real)'''); 3050 | disp(' '); 3051 | 3052 | r = rsave; 3053 | 3054 | r = r + 1; 3055 | A = rand(1,1) + rand(1,1)*1i; 3056 | B = rand(1,10000); 3057 | maxdiffGC('conj(Scalar) * Vector'' ',A,B,r); 3058 | 3059 | r = r + 1; 3060 | A = rand(10000,1)+ rand(10000,1)*1i; 3061 | B = rand(1,1); 3062 | maxdiffGC('conj(Vector) * Scalar'' ',A,B,r); 3063 | 3064 | r = r + 1; 3065 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 3066 | B = rand(1,1); 3067 | maxdiffGC('conj(Array) * Scalar'' ',A,B,r); 3068 | 3069 | r = r + 1; 3070 | A = rand(1,10000000) + rand(1,10000000)*1i; 3071 | B = rand(1,10000000); 3072 | maxdiffGC('conj(Vector) i Vector'' ',A,B,r); 3073 | 3074 | r = r + 1; 3075 | A = rand(2500,1) + rand(2500,1)*1i; 3076 | B = rand(2500,1); 3077 | maxdiffGC('conj(Vector) o Vector'' ',A,B,r); 3078 | 3079 | r = r + 1; 3080 | A = rand(1,1000) + rand(1,1000)*1i; 3081 | B = rand(1000,1000); 3082 | maxdiffGC('conj(Vector) * Matrix'' ',A,B,r); 3083 | 3084 | r = r + 1; 3085 | A = rand(1000,1000) + rand(1000,1000)*1i; 3086 | B = rand(1,1000); 3087 | maxdiffGC('conj(Matrix) * Vector'' ',A,B,r); 3088 | 3089 | r = r + 1; 3090 | A = rand(1000,1000) + rand(1000,1000)*1i; 3091 | B = rand(1000,1000); 3092 | maxdiffGC('conj(Matrix) * Matrix'' ',A,B,r); 3093 | 3094 | %-------------------------------------------------------------------------- 3095 | disp(' '); 3096 | disp('conj(complex) * (complex)'''); 3097 | disp(' '); 3098 | 3099 | r = rsave; 3100 | 3101 | r = r + 1; 3102 | A = rand(1,1) + rand(1,1)*1i; 3103 | B = rand(1,10000) + rand(1,10000)*1i; 3104 | maxdiffGC('conj(Scalar) * Vector'' ',A,B,r); 3105 | 3106 | r = r + 1; 3107 | A = rand(10000,1)+ rand(10000,1)*1i; 3108 | B = rand(1,1) + rand(1,1)*1i; 3109 | maxdiffGC('conj(Vector) * Scalar'' ',A,B,r); 3110 | 3111 | r = r + 1; 3112 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 3113 | B = rand(1,1) + rand(1,1)*1i; 3114 | maxdiffGC('conj(Array) * Scalar'' ',A,B,r); 3115 | 3116 | r = r + 1; 3117 | A = rand(1,10000000) + rand(1,10000000)*1i; 3118 | B = rand(1,10000000) + rand(1,10000000)*1i; 3119 | maxdiffGC('conj(Vector) i Vector'' ',A,B,r); 3120 | 3121 | r = r + 1; 3122 | A = rand(2500,1) + rand(2500,1)*1i; 3123 | B = rand(2500,1) + rand(2500,1)*1i; 3124 | maxdiffGC('conj(Vector) o Vector'' ',A,B,r); 3125 | 3126 | r = r + 1; 3127 | A = rand(1,1000) + rand(1,1000)*1i; 3128 | B = rand(1000,1000) + rand(1000,1000)*1i; 3129 | maxdiffGC('conj(Vector) * Matrix'' ',A,B,r); 3130 | 3131 | r = r + 1; 3132 | A = rand(1000,1000) + rand(1000,1000)*1i; 3133 | B = rand(1,1000) + rand(1,1000)*1i; 3134 | maxdiffGC('conj(Matrix) * Vector'' ',A,B,r); 3135 | 3136 | r = r + 1; 3137 | A = rand(1000,1000) + rand(1000,1000)*1i; 3138 | B = rand(1000,1000) + rand(1000,1000)*1i; 3139 | maxdiffGC('conj(Matrix) * Matrix'' ',A,B,r); 3140 | 3141 | running_time(datenum(clock) - start_time); 3142 | 3143 | %-------------------------------------------------------------------------- 3144 | %-------------------------------------------------------------------------- 3145 | 3146 | %end % debug jump 3147 | 3148 | disp(' '); 3149 | disp('Numerical Comparison Tests ...'); 3150 | disp(' '); 3151 | disp('conj(real) * conj(real)'); 3152 | disp(' '); 3153 | 3154 | if( isequal(conj([])*conj([]),mtimesx([],'G',[],'G')) ) 3155 | disp('conj(Empty) * conj(Empty) EQUAL'); 3156 | else 3157 | disp('conj(Empty) * conj(Empty) NOT EQUAL <---'); 3158 | end 3159 | 3160 | r = r + 1; 3161 | mtimesx_dtable(r,:) = RC; 3162 | 3163 | rsave = r; 3164 | 3165 | r = r + 1; 3166 | A = rand(1,1); 3167 | B = rand(1,10000); 3168 | maxdiffGG('conj(Scalar) * conj(Vector) ',A,B,r); 3169 | 3170 | r = r + 1; 3171 | A = rand(1,10000); 3172 | B = rand(1,1); 3173 | maxdiffGG('conj(Vector) * conj(Scalar) ',A,B,r); 3174 | 3175 | r = r + 1; 3176 | A = rand(1,1); 3177 | B = rand(10,20,30,40); 3178 | maxdiffGG('conj(Scalar) * conj(Array) ',A,B,r); 3179 | 3180 | r = r + 1; 3181 | A = rand(10,20,30,40); 3182 | B = rand(1,1); 3183 | maxdiffGG('conj(Array) * conj(Scalar) ',A,B,r); 3184 | 3185 | r = r + 1; 3186 | A = rand(1,10000000); 3187 | B = rand(10000000,1); 3188 | maxdiffGG('conj(Vector) i conj(Vector) ',A,B,r); 3189 | 3190 | r = r + 1; 3191 | A = rand(2500,1); 3192 | B = rand(1,2500); 3193 | maxdiffGG('conj(Vector) o conj(Vector) ',A,B,r); 3194 | 3195 | r = r + 1; 3196 | A = rand(1,1000); 3197 | B = rand(1000,1000); 3198 | maxdiffGG('conj(Vector) * conj(Matrix) ',A,B,r); 3199 | 3200 | r = r + 1; 3201 | A = rand(1000,1000); 3202 | B = rand(1000,1); 3203 | maxdiffGG('conj(Matrix) * conj(Vector) ',A,B,r); 3204 | 3205 | r = r + 1; 3206 | A = rand(1000,1000); 3207 | B = rand(1000,1000); 3208 | maxdiffGG('conj(Matrix) * conj(Matrix) ',A,B,r); 3209 | 3210 | %-------------------------------------------------------------------------- 3211 | disp(' '); 3212 | disp('conj(real) * conj(complex)'); 3213 | disp(' '); 3214 | 3215 | r = rsave; 3216 | 3217 | r = r + 1; 3218 | A = rand(1,1); 3219 | B = rand(1,10000) + rand(1,10000)*1i; 3220 | maxdiffGG('conj(Scalar) * conj(Vector) ',A,B,r); 3221 | 3222 | r = r + 1; 3223 | A = rand(1,10000); 3224 | B = rand(1,1) + rand(1,1)*1i; 3225 | maxdiffGG('conj(Vector) * conj(Scalar) ',A,B,r); 3226 | 3227 | r = r + 1; 3228 | A = rand(1,1); 3229 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 3230 | maxdiffGG('conj(Scalar) * conj(Array) ',A,B,r); 3231 | 3232 | r = r + 1; 3233 | A = rand(10,20,30,40); 3234 | B = rand(1,1) + rand(1,1)*1i; 3235 | maxdiffGG('conj(Array) * conj(Scalar) ',A,B,r); 3236 | 3237 | r = r + 1; 3238 | A = rand(1,10000000); 3239 | B = rand(10000000,1) + rand(10000000,1)*1i; 3240 | maxdiffGG('conj(Vector) i conj(Vector) ',A,B,r); 3241 | 3242 | r = r + 1; 3243 | A = rand(2500,1); 3244 | B = rand(1,2500) + rand(1,2500)*1i; 3245 | maxdiffGG('conj(Vector) o conj(Vector) ',A,B,r); 3246 | 3247 | r = r + 1; 3248 | A = rand(1,1000); 3249 | B = rand(1000,1000) + rand(1000,1000)*1i; 3250 | maxdiffGG('conj(Vector) * conj(Matrix) ',A,B,r); 3251 | 3252 | r = r + 1; 3253 | A = rand(1000,1000); 3254 | B = rand(1000,1) + rand(1000,1)*1i; 3255 | maxdiffGG('conj(Matrix) * conj(Vector) ',A,B,r); 3256 | 3257 | r = r + 1; 3258 | A = rand(1000,1000); 3259 | B = rand(1000,1000) + rand(1000,1000)*1i; 3260 | maxdiffGG('conj(Matrix) * conj(Matrix) ',A,B,r); 3261 | 3262 | %-------------------------------------------------------------------------- 3263 | disp(' '); 3264 | disp('conj(complex)* conj(real)'); 3265 | disp(' '); 3266 | 3267 | r = rsave; 3268 | 3269 | r = r + 1; 3270 | A = rand(1,1) + rand(1,1)*1i; 3271 | B = rand(1,10000); 3272 | maxdiffGG('conj(Scalar) * conj(Vector) ',A,B,r); 3273 | 3274 | r = r + 1; 3275 | A = rand(1,10000)+ rand(1,10000)*1i; 3276 | B = rand(1,1); 3277 | maxdiffGG('conj(Vector) * conj(Scalar) ',A,B,r); 3278 | 3279 | r = r + 1; 3280 | A = rand(1,1) + rand(1,1)*1i; 3281 | B = rand(10,20,30,40); 3282 | maxdiffGG('conj(Scalar) * conj(Array) ',A,B,r); 3283 | 3284 | r = r + 1; 3285 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 3286 | B = rand(1,1); 3287 | maxdiffGG('conj(Array) * conj(Scalar) ',A,B,r); 3288 | 3289 | r = r + 1; 3290 | A = rand(1,10000000) + rand(1,10000000)*1i; 3291 | B = rand(10000000,1); 3292 | maxdiffGG('conj(Vector) i conj(Vector) ',A,B,r); 3293 | 3294 | r = r + 1; 3295 | A = rand(2500,1) + rand(2500,1)*1i; 3296 | B = rand(1,2500); 3297 | maxdiffGG('conj(Vector) o conj(Vector) ',A,B,r); 3298 | 3299 | r = r + 1; 3300 | A = rand(1,1000) + rand(1,1000)*1i; 3301 | B = rand(1000,1000); 3302 | maxdiffGG('conj(Vector) * conj(Matrix) ',A,B,r); 3303 | 3304 | r = r + 1; 3305 | A = rand(1000,1000) + rand(1000,1000)*1i; 3306 | B = rand(1000,1); 3307 | maxdiffGG('conj(Matrix) * conj(Vector) ',A,B,r); 3308 | 3309 | r = r + 1; 3310 | A = rand(1000,1000) + rand(1000,1000)*1i; 3311 | B = rand(1000,1000); 3312 | maxdiffGG('conj(Matrix) * conj(Matrix) ',A,B,r); 3313 | 3314 | %-------------------------------------------------------------------------- 3315 | disp(' '); 3316 | disp('conj(complex)* conj(complex)'); 3317 | disp(' '); 3318 | 3319 | r = rsave; 3320 | 3321 | r = r + 1; 3322 | A = rand(1,1) + rand(1,1)*1i; 3323 | B = rand(1,10000) + rand(1,10000)*1i; 3324 | maxdiffGG('conj(Scalar) * conj(Vector) ',A,B,r); 3325 | 3326 | r = r + 1; 3327 | A = rand(1,10000)+ rand(1,10000)*1i; 3328 | B = rand(1,1) + rand(1,1)*1i; 3329 | maxdiffGG('conj(Vector) * conj(Scalar) ',A,B,r); 3330 | 3331 | r = r + 1; 3332 | A = rand(1,1) + rand(1,1)*1i; 3333 | B = rand(10,20,30,40) + rand(10,20,30,40)*1i; 3334 | maxdiffGG('conj(Scalar) * conj(Array) ',A,B,r); 3335 | 3336 | r = r + 1; 3337 | A = rand(10,20,30,40) + rand(10,20,30,40)*1i; 3338 | B = rand(1,1) + rand(1,1)*1i; 3339 | maxdiffGG('conj(Array) * conj(Scalar) ',A,B,r); 3340 | 3341 | r = r + 1; 3342 | A = rand(1,10000000) + rand(1,10000000)*1i; 3343 | B = rand(10000000,1) + rand(10000000,1)*1i; 3344 | maxdiffGG('conj(Vector) i conj(Vector) ',A,B,r); 3345 | 3346 | r = r + 1; 3347 | A = rand(2500,1) + rand(2500,1)*1i; 3348 | B = rand(1,2500) + rand(1,2500)*1i; 3349 | maxdiffGG('conj(Vector) o conj(Vector) ',A,B,r); 3350 | 3351 | r = r + 1; 3352 | A = rand(1,1000) + rand(1,1000)*1i; 3353 | B = rand(1000,1000) + rand(1000,1000)*1i; 3354 | maxdiffGG('conj(Vector) * conj(Matrix) ',A,B,r); 3355 | 3356 | r = r + 1; 3357 | A = rand(1000,1000) + rand(1000,1000)*1i; 3358 | B = rand(1000,1) + rand(1000,1)*1i; 3359 | maxdiffGG('conj(Matrix) * conj(Vector) ',A,B,r); 3360 | 3361 | r = r + 1; 3362 | A = rand(1000,1000) + rand(1000,1000)*1i; 3363 | B = rand(1000,1000) + rand(1000,1000)*1i; 3364 | maxdiffGG('conj(Matrix) * conj(Matrix) ',A,B,r); 3365 | 3366 | running_time(datenum(clock) - start_time); 3367 | 3368 | %-------------------------------------------------------------------------- 3369 | %-------------------------------------------------------------------------- 3370 | 3371 | %end % debug jump 3372 | 3373 | disp('----------------------------------'); 3374 | disp(' '); 3375 | disp('Numerical Comparison Tests ... symmetric cases op(A) * op(A)'); 3376 | disp(' '); 3377 | disp('real'); 3378 | 3379 | r = r + 1; 3380 | mtimesx_dtable(r,:) = RC; 3381 | 3382 | rsave = r; 3383 | 3384 | r = r + 1; 3385 | A = rand(2000); 3386 | maxdiffsymCN('Matrix'' * Same ',A,r); 3387 | 3388 | r = r + 1; 3389 | A = rand(2000); 3390 | maxdiffsymNC('Matrix * Same''',A,r); 3391 | 3392 | r = r + 1; 3393 | A = rand(2000); 3394 | maxdiffsymTN('Matrix.'' * Same ',A,r); 3395 | 3396 | r = r + 1; 3397 | A = rand(2000); 3398 | maxdiffsymNT('Matrix * Same.''',A,r); 3399 | 3400 | r = r + 1; 3401 | A = rand(2000); 3402 | maxdiffsymGC('conj(Matrix) * Same''',A,r); 3403 | 3404 | r = r + 1; 3405 | A = rand(2000); 3406 | maxdiffsymCG('Matrix'' * conj(Same)',A,r); 3407 | 3408 | r = r + 1; 3409 | A = rand(2000); 3410 | maxdiffsymGT('conj(Matrix) * Same.'' ',A,r); 3411 | 3412 | r = r + 1; 3413 | A = rand(2000); 3414 | maxdiffsymTG('Matrix.'' * conj(Same)',A,r); 3415 | 3416 | r = rsave; 3417 | 3418 | disp(' ' ); 3419 | disp('complex'); 3420 | 3421 | r = r + 1; 3422 | A = rand(2000) + rand(2000)*1i; 3423 | maxdiffsymCN('Matrix'' * Same ',A,r); 3424 | 3425 | r = r + 1; 3426 | A = rand(2000) + rand(2000)*1i; 3427 | maxdiffsymNC('Matrix * Same''',A,r); 3428 | 3429 | r = r + 1; 3430 | A = rand(2000) + rand(2000)*1i; 3431 | maxdiffsymTN('Matrix.'' * Same ',A,r); 3432 | 3433 | r = r + 1; 3434 | A = rand(2000) + rand(2000)*1i; 3435 | maxdiffsymNT('Matrix * Same.''',A,r); 3436 | 3437 | r = r + 1; 3438 | A = rand(2000) + rand(2000)*1i; 3439 | maxdiffsymGC('conj(Matrix) * Same''',A,r); 3440 | 3441 | r = r + 1; 3442 | A = rand(2000) + rand(2000)*1i; 3443 | maxdiffsymCG('Matrix'' * conj(Same)',A,r); 3444 | 3445 | r = r + 1; 3446 | A = rand(2000) + rand(2000)*1i; 3447 | maxdiffsymGT('conj(Matrix) * Same.''',A,r); 3448 | 3449 | r = r + 1; 3450 | A = rand(2000) + rand(2000)*1i; 3451 | maxdiffsymTG('Matrix.'' * conj(Same)',A,r); 3452 | 3453 | running_time(datenum(clock) - start_time); 3454 | 3455 | %-------------------------------------------------------------------------- 3456 | %-------------------------------------------------------------------------- 3457 | 3458 | %end % debug jump 3459 | 3460 | disp(' '); 3461 | disp('Numerical Comparison Tests ... special scalar cases'); 3462 | disp(' '); 3463 | disp('(scalar) * (real)'); 3464 | disp(' '); 3465 | 3466 | r = r + 1; 3467 | mtimesx_dtable(r,:) = ' Real*Real Real*Cplx Cplx*Real Cplx*Cplx'; 3468 | 3469 | rsave = r; 3470 | 3471 | r = r + 1; 3472 | A = 1; 3473 | B = rand(2500); 3474 | maxdiffNN('( 1+0i) * Matrix ',A,B,r); 3475 | 3476 | r = r + 1; 3477 | A = 1 + 1i; 3478 | B = rand(2500); 3479 | maxdiffNN('( 1+1i) * Matrix ',A,B,r); 3480 | 3481 | r = r + 1; 3482 | A = 1 - 1i; 3483 | B = rand(2500); 3484 | maxdiffNN('( 1-1i) * Matrix ',A,B,r); 3485 | 3486 | r = r + 1; 3487 | A = 1 + 2i; 3488 | B = rand(2500); 3489 | maxdiffNN('( 1+2i) * Matrix ',A,B,r); 3490 | 3491 | r = r + 1; 3492 | A = -1; 3493 | B = rand(2500); 3494 | maxdiffNN('(-1+0i) * Matrix ',A,B,r); 3495 | 3496 | r = r + 1; 3497 | A = -1 + 1i; 3498 | B = rand(2500); 3499 | maxdiffNN('(-1+1i) * Matrix ',A,B,r); 3500 | 3501 | r = r + 1; 3502 | A = -1 - 1i; 3503 | B = rand(2500); 3504 | maxdiffNN('(-1-1i) * Matrix ',A,B,r); 3505 | 3506 | r = r + 1; 3507 | A = -1 + 2i; 3508 | B = rand(2500); 3509 | maxdiffNN('(-1+2i) * Matrix ',A,B,r); 3510 | 3511 | r = r + 1; 3512 | A = 2 + 1i; 3513 | B = rand(2500); 3514 | maxdiffNN('( 2+1i) * Matrix ',A,B,r); 3515 | 3516 | r = r + 1; 3517 | A = 2 - 1i; 3518 | B = rand(2500); 3519 | maxdiffNN('( 2-1i) * Matrix ',A,B,r); 3520 | 3521 | disp(' '); 3522 | disp('(scalar) * (complex)'); 3523 | disp(' '); 3524 | 3525 | r = rsave; 3526 | 3527 | r = r + 1; 3528 | A = 1; 3529 | B = rand(2500) + rand(2500)*1i; 3530 | maxdiffNN('( 1+0i) * Matrix ',A,B,r); 3531 | 3532 | r = r + 1; 3533 | A = 1 + 1i; 3534 | B = rand(2500) + rand(2500)*1i; 3535 | maxdiffNN('( 1+1i) * Matrix ',A,B,r); 3536 | 3537 | r = r + 1; 3538 | A = 1 - 1i; 3539 | B = rand(2500) + rand(2500)*1i; 3540 | maxdiffNN('( 1-1i) * Matrix ',A,B,r); 3541 | 3542 | r = r + 1; 3543 | A = 1 + 2i; 3544 | B = rand(2500) + rand(2500)*1i; 3545 | maxdiffNN('( 1+2i) * Matrix ',A,B,r); 3546 | 3547 | r = r + 1; 3548 | A = -1; 3549 | B = rand(2500) + rand(2500)*1i; 3550 | maxdiffNN('(-1+0i) * Matrix ',A,B,r); 3551 | 3552 | r = r + 1; 3553 | A = -1 + 1i; 3554 | B = rand(2500) + rand(2500)*1i; 3555 | maxdiffNN('(-1+1i) * Matrix ',A,B,r); 3556 | 3557 | r = r + 1; 3558 | A = -1 - 1i; 3559 | B = rand(2500) + rand(2500)*1i; 3560 | maxdiffNN('(-1-1i) * Matrix ',A,B,r); 3561 | 3562 | r = r + 1; 3563 | A = -1 + 2i; 3564 | B = rand(2500) + rand(2500)*1i; 3565 | maxdiffNN('(-1+2i) * Matrix ',A,B,r); 3566 | 3567 | r = r + 1; 3568 | A = 2 + 1i; 3569 | B = rand(2500) + rand(2500)*1i; 3570 | maxdiffNN('( 2+1i) * Matrix ',A,B,r); 3571 | 3572 | r = r + 1; 3573 | A = 2 - 1i; 3574 | B = rand(2500) + rand(2500)*1i; 3575 | maxdiffNN('( 2-1i) * Matrix ',A,B,r); 3576 | 3577 | disp(' '); 3578 | disp('(scalar) * (complex)'''); 3579 | disp(' '); 3580 | 3581 | %r = rsave; 3582 | 3583 | r = r + 1; 3584 | A = 1; 3585 | B = rand(2500) + rand(2500)*1i; 3586 | maxdiffNC('( 1+0i) * Matrix'' ',A,B,r); 3587 | 3588 | r = r + 1; 3589 | A = 1 + 1i; 3590 | B = rand(2500) + rand(2500)*1i; 3591 | maxdiffNC('( 1+1i) * Matrix'' ',A,B,r); 3592 | 3593 | r = r + 1; 3594 | A = 1 - 1i; 3595 | B = rand(2500) + rand(2500)*1i; 3596 | maxdiffNC('( 1-1i) * Matrix'' ',A,B,r); 3597 | 3598 | r = r + 1; 3599 | A = 1 + 2i; 3600 | B = rand(2500) + rand(2500)*1i; 3601 | maxdiffNC('( 1+2i) * Matrix'' ',A,B,r); 3602 | 3603 | r = r + 1; 3604 | A = -1; 3605 | B = rand(2500) + rand(2500)*1i; 3606 | maxdiffNC('(-1+0i) * Matrix'' ',A,B,r); 3607 | 3608 | r = r + 1; 3609 | A = -1 + 1i; 3610 | B = rand(2500) + rand(2500)*1i; 3611 | maxdiffNC('(-1+1i) * Matrix'' ',A,B,r); 3612 | 3613 | r = r + 1; 3614 | A = -1 - 1i; 3615 | B = rand(2500) + rand(2500)*1i; 3616 | maxdiffNC('(-1-1i) * Matrix'' ',A,B,r); 3617 | 3618 | r = r + 1; 3619 | A = -1 + 2i; 3620 | B = rand(2500) + rand(2500)*1i; 3621 | maxdiffNC('(-1+2i) * Matrix'' ',A,B,r); 3622 | 3623 | r = r + 1; 3624 | A = 2 + 1i; 3625 | B = rand(2500) + rand(2500)*1i; 3626 | maxdiffNC('( 2+1i) * Matrix'' ',A,B,r); 3627 | 3628 | r = r + 1; 3629 | A = 2 - 1i; 3630 | B = rand(2500) + rand(2500)*1i; 3631 | maxdiffNC('( 2-1i) * Matrix'' ',A,B,r); 3632 | 3633 | running_time(datenum(clock) - start_time); 3634 | 3635 | %-------------------------------------------------------------------------- 3636 | %-------------------------------------------------------------------------- 3637 | 3638 | %end % debug jump 3639 | 3640 | disp(' '); 3641 | disp('Numerical Comparison Tests ... special (scalar) * (sparse) cases'); 3642 | disp('Real * Real, Real * Cmpx, Cmpx * Real, Cmpx * Cmpx'); 3643 | disp(' '); 3644 | 3645 | r = r + 1; 3646 | mtimesx_dtable(r,:) = RC; 3647 | 3648 | % rsave = r; 3649 | 3650 | r = r + 1; 3651 | A = rand(1,1); 3652 | B = sprand(5000,5000,.1); 3653 | maxdiffNN('Scalar * Sparse',A,B,r); 3654 | 3655 | A = rand(1,1); 3656 | B = sprand(5000,5000,.1); B = B + B*2i; 3657 | maxdiffNN('Scalar * Sparse',A,B,r); 3658 | 3659 | A = rand(1,1) + rand(1,1)*1i; 3660 | B = sprand(5000,5000,.1); 3661 | maxdiffNN('Scalar * Sparse',A,B,r); 3662 | 3663 | A = rand(1,1) + rand(1,1)*1i; 3664 | B = sprand(5000,5000,.1); B = B + B*2i; 3665 | maxdiffNN('Scalar * Sparse',A,B,r); 3666 | 3667 | r = r + 1; 3668 | A = rand(1,1); 3669 | B = sprand(5000,5000,.1); 3670 | maxdiffNT('Scalar * Sparse.''',A,B,r); 3671 | 3672 | A = rand(1,1); 3673 | B = sprand(5000,5000,.1); B = B + B*2i; 3674 | maxdiffNT('Scalar * Sparse.''',A,B,r); 3675 | 3676 | A = rand(1,1) + rand(1,1)*1i; 3677 | B = sprand(5000,5000,.1); 3678 | maxdiffNT('Scalar * Sparse.''',A,B,r); 3679 | 3680 | A = rand(1,1) + rand(1,1)*1i; 3681 | B = sprand(5000,5000,.1); B = B + B*2i; 3682 | maxdiffNT('Scalar * Sparse.''',A,B,r); 3683 | 3684 | r = r + 1; 3685 | A = rand(1,1); 3686 | B = sprand(5000,5000,.1); 3687 | maxdiffNC('Scalar * Sparse''',A,B,r); 3688 | 3689 | A = rand(1,1); 3690 | B = sprand(5000,5000,.1); B = B + B*2i; 3691 | maxdiffNC('Scalar * Sparse''',A,B,r); 3692 | 3693 | A = rand(1,1) + rand(1,1)*1i; 3694 | B = sprand(5000,5000,.1); 3695 | maxdiffNC('Scalar * Sparse''',A,B,r); 3696 | 3697 | A = rand(1,1) + rand(1,1)*1i; 3698 | B = sprand(5000,5000,.1); B = B + B*2i; 3699 | maxdiffNC('Scalar * Sparse''',A,B,r); 3700 | 3701 | r = r + 1; 3702 | A = rand(1,1); 3703 | B = sprand(5000,5000,.1); 3704 | maxdiffNG('Scalar * conj(Sparse)',A,B,r); 3705 | 3706 | A = rand(1,1); 3707 | B = sprand(5000,5000,.1); B = B + B*2i; 3708 | maxdiffNG('Scalar * conj(Sparse)',A,B,r); 3709 | 3710 | A = rand(1,1) + rand(1,1)*1i; 3711 | B = sprand(5000,5000,.1); 3712 | maxdiffNG('Scalar * conj(Sparse)',A,B,r); 3713 | 3714 | A = rand(1,1) + rand(1,1)*1i; 3715 | B = sprand(5000,5000,.1); B = B + B*2i; 3716 | maxdiffNG('Scalar * conj(Sparse)',A,B,r); 3717 | 3718 | running_time(datenum(clock) - start_time); 3719 | 3720 | %-------------------------------------------------------------------------- 3721 | %-------------------------------------------------------------------------- 3722 | 3723 | disp(' '); 3724 | disp(' --- DONE ! ---'); 3725 | disp(' '); 3726 | disp('Summary of Numerical Comparison Tests, max relative element difference:'); 3727 | disp(' '); 3728 | mtimesx_dtable(1,1:k) = compver; 3729 | disp(mtimesx_dtable); 3730 | disp(' '); 3731 | 3732 | dtable = mtimesx_dtable; 3733 | 3734 | end 3735 | 3736 | %-------------------------------------------------------------------------- 3737 | %-------------------------------------------------------------------------- 3738 | 3739 | function maxdiffNN(T,A,B,r) 3740 | Cm = A*B; 3741 | Cx = mtimesx(A,B); 3742 | maxdiffout(T,A,B,Cm,Cx,r); 3743 | return 3744 | end 3745 | 3746 | %-------------------------------------------------------------------------- 3747 | %-------------------------------------------------------------------------- 3748 | 3749 | function maxdiffCN(T,A,B,r) 3750 | Cm = A'*B; 3751 | Cx = mtimesx(A,'C',B); 3752 | maxdiffout(T,A,B,Cm,Cx,r); 3753 | return 3754 | end 3755 | 3756 | %-------------------------------------------------------------------------- 3757 | %-------------------------------------------------------------------------- 3758 | 3759 | function maxdiffTN(T,A,B,r) 3760 | Cm = A.'*B; 3761 | Cx = mtimesx(A,'T',B); 3762 | maxdiffout(T,A,B,Cm,Cx,r); 3763 | return 3764 | end 3765 | 3766 | %-------------------------------------------------------------------------- 3767 | %-------------------------------------------------------------------------- 3768 | 3769 | function maxdiffGN(T,A,B,r) 3770 | Cm = conj(A)*B; 3771 | Cx = mtimesx(A,'G',B); 3772 | maxdiffout(T,A,B,Cm,Cx,r); 3773 | return 3774 | end 3775 | 3776 | %-------------------------------------------------------------------------- 3777 | %-------------------------------------------------------------------------- 3778 | 3779 | function maxdiffNC(T,A,B,r) 3780 | Cm = A*B'; 3781 | Cx = mtimesx(A,B,'C'); 3782 | maxdiffout(T,A,B,Cm,Cx,r); 3783 | return 3784 | end 3785 | 3786 | %-------------------------------------------------------------------------- 3787 | %-------------------------------------------------------------------------- 3788 | 3789 | function maxdiffCC(T,A,B,r) 3790 | Cm = A'*B'; 3791 | Cx = mtimesx(A,'C',B,'C'); 3792 | maxdiffout(T,A,B,Cm,Cx,r); 3793 | return 3794 | end 3795 | 3796 | %-------------------------------------------------------------------------- 3797 | %-------------------------------------------------------------------------- 3798 | 3799 | function maxdiffTC(T,A,B,r) 3800 | Cm = A.'*B'; 3801 | Cx = mtimesx(A,'T',B,'C'); 3802 | maxdiffout(T,A,B,Cm,Cx,r); 3803 | return 3804 | end 3805 | 3806 | %-------------------------------------------------------------------------- 3807 | %-------------------------------------------------------------------------- 3808 | 3809 | function maxdiffGC(T,A,B,r) 3810 | Cm = conj(A)*B'; 3811 | Cx = mtimesx(A,'G',B,'C'); 3812 | maxdiffout(T,A,B,Cm,Cx,r); 3813 | return 3814 | end 3815 | 3816 | %-------------------------------------------------------------------------- 3817 | %-------------------------------------------------------------------------- 3818 | 3819 | function maxdiffNT(T,A,B,r) 3820 | Cm = A*B.'; 3821 | Cx = mtimesx(A,B,'T'); 3822 | maxdiffout(T,A,B,Cm,Cx,r); 3823 | return 3824 | end 3825 | 3826 | %-------------------------------------------------------------------------- 3827 | %-------------------------------------------------------------------------- 3828 | 3829 | function maxdiffCT(T,A,B,r) 3830 | Cm = A'*B.'; 3831 | Cx = mtimesx(A,'C',B,'T'); 3832 | maxdiffout(T,A,B,Cm,Cx,r); 3833 | return 3834 | end 3835 | 3836 | %-------------------------------------------------------------------------- 3837 | %-------------------------------------------------------------------------- 3838 | 3839 | function maxdiffTT(T,A,B,r) 3840 | Cm = A.'*B.'; 3841 | Cx = mtimesx(A,'T',B,'T'); 3842 | maxdiffout(T,A,B,Cm,Cx,r); 3843 | return 3844 | end 3845 | 3846 | %-------------------------------------------------------------------------- 3847 | %-------------------------------------------------------------------------- 3848 | 3849 | function maxdiffGT(T,A,B,r) 3850 | Cm = conj(A)*B.'; 3851 | Cx = mtimesx(A,'G',B,'T'); 3852 | maxdiffout(T,A,B,Cm,Cx,r); 3853 | return 3854 | end 3855 | 3856 | %-------------------------------------------------------------------------- 3857 | %-------------------------------------------------------------------------- 3858 | 3859 | function maxdiffNG(T,A,B,r) 3860 | Cm = A*conj(B); 3861 | Cx = mtimesx(A,B,'G'); 3862 | maxdiffout(T,A,B,Cm,Cx,r); 3863 | return 3864 | end 3865 | 3866 | %-------------------------------------------------------------------------- 3867 | %-------------------------------------------------------------------------- 3868 | 3869 | function maxdiffCG(T,A,B,r) 3870 | Cm = A'*conj(B); 3871 | Cx = mtimesx(A,'C',B,'G'); 3872 | maxdiffout(T,A,B,Cm,Cx,r); 3873 | return 3874 | end 3875 | 3876 | %-------------------------------------------------------------------------- 3877 | %-------------------------------------------------------------------------- 3878 | 3879 | function maxdiffTG(T,A,B,r) 3880 | Cm = A.'*conj(B); 3881 | Cx = mtimesx(A,'T',B,'G'); 3882 | maxdiffout(T,A,B,Cm,Cx,r); 3883 | return 3884 | end 3885 | 3886 | %-------------------------------------------------------------------------- 3887 | %-------------------------------------------------------------------------- 3888 | 3889 | function maxdiffGG(T,A,B,r) 3890 | Cm = conj(A)*conj(B); 3891 | Cx = mtimesx(A,'G',B,'G'); 3892 | maxdiffout(T,A,B,Cm,Cx,r); 3893 | return 3894 | end 3895 | 3896 | %-------------------------------------------------------------------------- 3897 | %-------------------------------------------------------------------------- 3898 | 3899 | function maxdiffsymCN(T,A,r) 3900 | Cm = A'*A; 3901 | Cx = mtimesx(A,'C',A); 3902 | maxdiffsymout(T,A,Cm,Cx,r); 3903 | return 3904 | end 3905 | 3906 | %-------------------------------------------------------------------------- 3907 | %-------------------------------------------------------------------------- 3908 | 3909 | function maxdiffsymNC(T,A,r) 3910 | Cm = A*A'; 3911 | Cx = mtimesx(A,A,'C'); 3912 | maxdiffsymout(T,A,Cm,Cx,r); 3913 | return 3914 | end 3915 | 3916 | %-------------------------------------------------------------------------- 3917 | %-------------------------------------------------------------------------- 3918 | 3919 | function maxdiffsymTN(T,A,r) 3920 | Cm = A.'*A; 3921 | Cx = mtimesx(A,'T',A); 3922 | maxdiffsymout(T,A,Cm,Cx,r); 3923 | return 3924 | end 3925 | 3926 | %-------------------------------------------------------------------------- 3927 | %-------------------------------------------------------------------------- 3928 | 3929 | function maxdiffsymNT(T,A,r) 3930 | Cm = A*A.'; 3931 | Cx = mtimesx(A,A,'T'); 3932 | maxdiffsymout(T,A,Cm,Cx,r); 3933 | return 3934 | end 3935 | 3936 | %-------------------------------------------------------------------------- 3937 | %-------------------------------------------------------------------------- 3938 | 3939 | function maxdiffsymTG(T,A,r) 3940 | Cm = A.'*conj(A); 3941 | Cx = mtimesx(A,'T',A,'G'); 3942 | maxdiffsymout(T,A,Cm,Cx,r); 3943 | return 3944 | end 3945 | 3946 | %-------------------------------------------------------------------------- 3947 | %-------------------------------------------------------------------------- 3948 | 3949 | function maxdiffsymGT(T,A,r) 3950 | Cm = conj(A)*A.'; 3951 | Cx = mtimesx(A,'G',A,'T'); 3952 | maxdiffsymout(T,A,Cm,Cx,r); 3953 | return 3954 | end 3955 | 3956 | %-------------------------------------------------------------------------- 3957 | %-------------------------------------------------------------------------- 3958 | 3959 | function maxdiffsymCG(T,A,r) 3960 | Cm = A'*conj(A); 3961 | Cx = mtimesx(A,'C',A,'G'); 3962 | maxdiffsymout(T,A,Cm,Cx,r); 3963 | return 3964 | end 3965 | 3966 | %-------------------------------------------------------------------------- 3967 | %-------------------------------------------------------------------------- 3968 | 3969 | function maxdiffsymGC(T,A,r) 3970 | Cm = conj(A)*A'; 3971 | Cx = mtimesx(A,'G',A,'C'); 3972 | maxdiffsymout(T,A,Cm,Cx,r); 3973 | return 3974 | end 3975 | 3976 | %-------------------------------------------------------------------------- 3977 | %-------------------------------------------------------------------------- 3978 | 3979 | function maxdiffout(T,A,B,Cm,Cx,r) 3980 | global mtimesx_dtable 3981 | lt = length(T); 3982 | b = repmat(' ',1,30-lt); 3983 | if( isequal(Cm,Cx) ) 3984 | disp([T b ' EQUAL']); 3985 | d = 0; 3986 | else 3987 | Cm = Cm(:); 3988 | Cx = Cx(:); 3989 | if( isreal(Cm) && isreal(Cx) ) 3990 | rx = Cx ~= Cm; 3991 | d = max(abs((Cx(rx)-Cm(rx))./Cm(rx))); 3992 | else 3993 | Cmr = real(Cm); 3994 | Cmi = imag(Cm); 3995 | Cxr = real(Cx); 3996 | Cxi = imag(Cx); 3997 | rx = Cxr ~= Cmr; 3998 | ix = Cxi ~= Cmi; 3999 | dr = max(abs((Cxr(rx)-Cmr(rx))./max(abs(Cmr(rx)),abs(Cmr(rx))))); 4000 | di = max(abs((Cxi(ix)-Cmi(ix))./max(abs(Cmi(ix)),abs(Cxi(ix))))); 4001 | if( isempty(dr) ) 4002 | d = di; 4003 | elseif( isempty(di) ) 4004 | d = dr; 4005 | else 4006 | d = max(dr,di); 4007 | end 4008 | end 4009 | disp([T b ' NOT EQUAL <--- Max relative difference: ' num2str(d)]); 4010 | end 4011 | mtimesx_dtable(r,1:length(T)) = T; 4012 | if( isreal(A) && isreal(B) ) 4013 | if( d == 0 ) 4014 | x = [T b ' 0']; 4015 | else 4016 | x = [T b sprintf('%11.2e',d)]; 4017 | end 4018 | mtimesx_dtable(r,1:length(x)) = x; 4019 | elseif( isreal(A) && ~isreal(B) ) 4020 | if( d == 0 ) 4021 | x = ' 0'; 4022 | else 4023 | x = sprintf('%11.2e',d); 4024 | end 4025 | mtimesx_dtable(r,42:41+length(x)) = x; 4026 | elseif( ~isreal(A) && isreal(B) ) 4027 | if( d == 0 ) 4028 | x = ' 0'; 4029 | else 4030 | x = sprintf('%11.2e',d); 4031 | end 4032 | mtimesx_dtable(r,53:52+length(x)) = x; 4033 | else 4034 | if( d == 0 ) 4035 | x = ' 0'; 4036 | else 4037 | x = sprintf('%11.2e',d); 4038 | end 4039 | mtimesx_dtable(r,64:63+length(x)) = x; 4040 | end 4041 | 4042 | return 4043 | end 4044 | 4045 | %-------------------------------------------------------------------------- 4046 | %-------------------------------------------------------------------------- 4047 | 4048 | function maxdiffsymout(T,A,Cm,Cx,r) 4049 | global mtimesx_dtable 4050 | lt = length(T); 4051 | b = repmat(' ',1,30-lt); 4052 | if( isequal(Cm,Cx) ) 4053 | disp([T b ' EQUAL']); 4054 | d = 0; 4055 | else 4056 | Cm = Cm(:); 4057 | Cx = Cx(:); 4058 | if( isreal(Cm) && isreal(Cx) ) 4059 | rx = Cx ~= Cm; 4060 | d = max(abs((Cx(rx)-Cm(rx))./Cm(rx))); 4061 | else 4062 | Cmr = real(Cm); 4063 | Cmi = imag(Cm); 4064 | Cxr = real(Cx); 4065 | Cxi = imag(Cx); 4066 | rx = Cxr ~= Cmr; 4067 | ix = Cxi ~= Cmi; 4068 | dr = max(abs((Cxr(rx)-Cmr(rx))./max(abs(Cmr(rx)),abs(Cmr(rx))))); 4069 | di = max(abs((Cxi(ix)-Cmi(ix))./max(abs(Cmi(ix)),abs(Cxi(ix))))); 4070 | if( isempty(dr) ) 4071 | d = di; 4072 | elseif( isempty(di) ) 4073 | d = dr; 4074 | else 4075 | d = max(dr,di); 4076 | end 4077 | end 4078 | disp([T b ' NOT EQUAL <--- Max relative difference: ' num2str(d)]); 4079 | end 4080 | if( isreal(A) ) 4081 | if( d == 0 ) 4082 | x = [T b ' 0']; 4083 | else 4084 | x = [T b sprintf('%11.2e',d)]; 4085 | end 4086 | mtimesx_dtable(r,1:length(x)) = x; 4087 | else 4088 | if( d == 0 ) 4089 | x = ' 0'; 4090 | else 4091 | x = sprintf('%11.2e',d); 4092 | end 4093 | mtimesx_dtable(r,1:length(T)) = T; 4094 | mtimesx_dtable(r,64:63+length(x)) = x; 4095 | end 4096 | 4097 | return 4098 | end 4099 | 4100 | %-------------------------------------------------------------------------- 4101 | %-------------------------------------------------------------------------- 4102 | 4103 | function running_time(d) 4104 | h = 24*d; 4105 | hh = floor(h); 4106 | m = 60*(h - hh); 4107 | mm = floor(m); 4108 | s = 60*(m - mm); 4109 | ss = floor(s); 4110 | disp(' '); 4111 | rt = sprintf('Running time hh:mm:ss = %2.0f:%2.0f:%2.0f',hh,mm,ss); 4112 | if( rt(28) == ' ' ) 4113 | rt(28) = '0'; 4114 | end 4115 | if( rt(31) == ' ' ) 4116 | rt(31) = '0'; 4117 | end 4118 | disp(rt); 4119 | disp(' '); 4120 | return 4121 | end 4122 | -------------------------------------------------------------------------------- /mtimesx_20110223/mtimesx_test_nd.m: -------------------------------------------------------------------------------- 1 | % Test routine for mtimesx, multi-dimensional speed and equality to MATLAB 2 | %****************************************************************************** 3 | % 4 | % MATLAB (R) is a trademark of The Mathworks (R) Corporation 5 | % 6 | % Function: mtimesx_test_nd 7 | % Filename: mtimesx_test_nd.m 8 | % Programmer: James Tursa 9 | % Version: 1.40 10 | % Date: October 4, 2010 11 | % Copyright: (c) 2009,2010 by James Tursa, All Rights Reserved 12 | % 13 | % This code uses the BSD License: 14 | % 15 | % Redistribution and use in source and binary forms, with or without 16 | % modification, are permitted provided that the following conditions are 17 | % met: 18 | % 19 | % * Redistributions of source code must retain the above copyright 20 | % notice, this list of conditions and the following disclaimer. 21 | % * Redistributions in binary form must reproduce the above copyright 22 | % notice, this list of conditions and the following disclaimer in 23 | % the documentation and/or other materials provided with the distribution 24 | % 25 | % THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" 26 | % AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 27 | % IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 28 | % ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE 29 | % LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 30 | % CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 31 | % SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 32 | % INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 33 | % CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 34 | % ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 35 | % POSSIBILITY OF SUCH DAMAGE. 36 | % 37 | % Syntax: 38 | % 39 | % A = mtimesx_test_nd % default n=4 is used 40 | % A = mtimesx_test_nd(n) 41 | % 42 | % where n = number of repetitions (should be 4 <= n <= 100) 43 | % 44 | % Output: 45 | % 46 | % Prints out speed and equality test results. 47 | % A = cell array with tabled results. 48 | % 49 | % 2010/Oct/04 --> 1.40, Added OpenMP support for custom code 50 | % Expanded sparse * single and sparse * nD support 51 | % 52 | %-------------------------------------------------------------------------- 53 | 54 | function Cr = mtimesx_test_nd(n) 55 | mtimesx; % load the mex routine into memory 56 | if( nargin == 0 ) 57 | n = 4; 58 | else 59 | n = floor(n); 60 | if( ~(n >= 4 && n <= 100) ) 61 | n = 4; 62 | end 63 | end 64 | cn = sprintf('%g',n); 65 | 66 | disp(' '); 67 | disp('MTIMESX multi-dimensional equality and speed tests'); 68 | disp('--------------------------------------------------'); 69 | disp(' '); 70 | disp('(M x K) * ( K x N) equality tests, SPEED mode, M,K,N <= 4'); 71 | trans = 'NGTC'; 72 | cmpx = {'real ','cmpx '}; 73 | mtimesx('speed'); 74 | smallok = true; 75 | for m=1:4 76 | for k=1:4 77 | for n=1:4 78 | for transa=1:4 79 | if( transa <= 2 ) 80 | ma = m; 81 | ka = k; 82 | else 83 | ma = k; 84 | ka = m; 85 | end 86 | for transb=1:4 87 | if( transb <= 2 ) 88 | kb = k; 89 | nb = n; 90 | else 91 | kb = n; 92 | nb = k; 93 | end 94 | for cmplxa=1:2 95 | if( cmplxa == 1 ) 96 | A = floor(rand(ma,ka)*100+1); 97 | else 98 | A = floor(rand(ma,ka)*100+1) + floor(rand(ma,ka)*100+1)*1i; 99 | end 100 | for cmplxb=1:2 101 | if( cmplxb == 1 ) 102 | B = floor(rand(kb,nb)*100+1); 103 | else 104 | B = floor(rand(kb,nb)*100+1) + floor(rand(kb,nb)*100+1)*1i; 105 | end 106 | Cm = mtimesx_sparse(A,trans(transa),B,trans(transb)); 107 | Cx = mtimesx(A,trans(transa),B,trans(transb)); 108 | if( isequal(Cm,Cx) ) 109 | disp(['(' cmpx{cmplxa} num2str(m) ' x ' num2str(k) ')' trans(transa) ... 110 | ' * (' cmpx{cmplxb} num2str(k) ' x ' num2str(n) ')' trans(transb) ' EQUAL']); 111 | else 112 | disp(['(' cmpx{cmplxa} num2str(m) ' x ' num2str(k) ')' trans(transa) ... 113 | ' * (' cmpx{cmplxb} num2str(k) ' x ' num2str(n) ')' trans(transb) ' NOT EQUAL']); 114 | smallok = false; 115 | end 116 | end 117 | end 118 | end 119 | end 120 | end 121 | end 122 | end 123 | 124 | if( mtimesx('openmp') ) 125 | disp(' '); 126 | disp('(M x K) * ( K x N) equality tests, SPEEDOMP mode, M,K,N <= 4'); 127 | mtimesx('speedomp'); 128 | smallokomp = true; 129 | for m=1:4 130 | for k=1:4 131 | for n=1:4 132 | for transa=1:4 133 | if( transa <= 2 ) 134 | ma = m; 135 | ka = k; 136 | else 137 | ma = k; 138 | ka = m; 139 | end 140 | for transb=1:4 141 | if( transb <= 2 ) 142 | kb = k; 143 | nb = n; 144 | else 145 | kb = n; 146 | nb = k; 147 | end 148 | for cmplxa=1:2 149 | if( cmplxa == 1 ) 150 | A = floor(rand(ma,ka)*100+1); 151 | else 152 | A = floor(rand(ma,ka)*100+1) + floor(rand(ma,ka)*100+1)*1i; 153 | end 154 | A = reshape(repmat(A,1000,1),ma,ka,1000); 155 | for cmplxb=1:2 156 | if( cmplxb == 1 ) 157 | B = floor(rand(kb,nb)*100+1); 158 | else 159 | B = floor(rand(kb,nb)*100+1) + floor(rand(kb,nb)*100+1)*1i; 160 | end 161 | B = reshape(repmat(B,1000,1),kb,nb,1000); 162 | Cm = mtimesx_sparse(A(:,:,1),trans(transa),B(:,:,1),trans(transb)); 163 | Cx = mtimesx(A,trans(transa),B,trans(transb)); 164 | if( isequal(Cm,Cx(:,:,1)) ) 165 | disp(['(' cmpx{cmplxa} num2str(m) ' x ' num2str(k) ')' trans(transa) ... 166 | ' * (' cmpx{cmplxb} num2str(k) ' x ' num2str(n) ')' trans(transb) ' EQUAL']); 167 | else 168 | disp(['(' cmpx{cmplxa} num2str(m) ' x ' num2str(k) ')' trans(transa) ... 169 | ' * (' cmpx{cmplxb} num2str(k) ' x ' num2str(n) ')' trans(transb) ' NOT EQUAL']); 170 | smallokomp = false; 171 | end 172 | end 173 | end 174 | end 175 | end 176 | end 177 | end 178 | end 179 | end 180 | 181 | disp(' '); 182 | if( smallok ) 183 | disp('All small matrix multiplies are OK in SPEED mode'); 184 | else 185 | disp('ERROR --> One or more of the small matrix multiplies was not equal in SPEED mode'); 186 | end 187 | if( mtimesx('openmp') ) 188 | if( smallokomp ) 189 | disp('All small matrix multiplies are OK in SPEEDOMP mode'); 190 | else 191 | disp('ERROR --> One or more of the small matrix multiplies was not equal in SPEEDOMP mode'); 192 | end 193 | end 194 | 195 | disp(' '); 196 | disp(['mtimesx multi-dimensional test routine using ' cn ' repetitions']); 197 | 198 | if( mtimesx('OPENMP') ) 199 | topm = 6; 200 | else 201 | topm = 4; 202 | end 203 | Cr = cell(6,topm+1); 204 | Cr{1,1} = 'All operands real'; 205 | 206 | for m=2:topm+1 207 | if( m == 2 ) 208 | mtimesx('BLAS'); 209 | elseif( m == 3 ) 210 | mtimesx('LOOPS'); 211 | elseif( m == 4 ) 212 | mtimesx('MATLAB'); 213 | elseif( m == 5 ) 214 | mtimesx('SPEED'); 215 | elseif( m == 6 ) 216 | mtimesx('LOOPSOMP'); 217 | else 218 | mtimesx('SPEEDOMP'); 219 | end 220 | Cr{1,m} = mtimesx; 221 | 222 | disp(' '); 223 | disp('--------------------------------------------------------------'); 224 | disp('--------------------------------------------------------------'); 225 | disp(' '); 226 | disp(['MTIMESX mode: ' mtimesx]); 227 | disp(' '); 228 | disp('(real 3x5x1x4x3x2x1x8) * (real 5x7x3x1x3x2x5) example'); 229 | Cr{2,1} = '(3x5xND) *(5x7xND)'; 230 | A = rand(3,5,1,4,3,2,1,8); 231 | B = rand(5,7,3,1,3,2,5); 232 | % mtimes 233 | tm = zeros(1,n); 234 | for k=1:n 235 | clear Cm 236 | A(1) = 2*A(1); 237 | B(1) = 2*B(1); 238 | tic 239 | Cm = zeros(3,7,3,4,3,2,5,8); 240 | for k1=1:3 241 | for k2=1:4 242 | for k3=1:3 243 | for k4=1:2 244 | for k5=1:5 245 | for k6=1:8 246 | Cm(:,:,k1,k2,k3,k4,k5,k6) = A(:,:,1,k2,k3,k4,1,k6) * B(:,:,k1,1,k3,k4,k5); 247 | end 248 | end 249 | end 250 | end 251 | end 252 | end 253 | tm(k) = toc; 254 | end 255 | % mtimesx 256 | tx = zeros(1,n); 257 | for k=1:n 258 | clear Cx 259 | tic 260 | Cx = mtimesx(A,B); 261 | tx(k) = toc; 262 | end 263 | % results 264 | tm = median(tm); 265 | tx = median(tx); 266 | if( tx < tm ) 267 | faster = sprintf('%7.1f',100*(tm)/tx-100); 268 | slower = ''; 269 | else 270 | faster = sprintf('%7.1f',-(100*(tx)/tm-100)); 271 | slower = ' (i.e., slower)'; 272 | end 273 | Cr{2,m} = faster; 274 | disp(' '); 275 | disp(['mtimes Elapsed time ' num2str(tm) ' seconds.']); 276 | disp(['MTIMESX Elapsed time ' num2str(tx) ' seconds.']); 277 | disp(['MTIMESX ' mtimesx ' mode is ' faster '% faster than MATLAB mtimes' slower]) 278 | if( isequal(Cx,Cm) ) 279 | disp(['MTIMESX ' mtimesx ' mode result matches mtimes: EQUAL']) 280 | else 281 | dx = max(abs(Cx(:)-Cm(:))); 282 | disp(['MTIMESX ' mtimesx ' mode result does not match mtimes: NOT EQUAL , max diff = ' num2str(dx)]) 283 | end 284 | 285 | disp(' '); 286 | disp('--------------------------------------------------------------'); 287 | disp('(real 3x3x1000000) * (real 3x3x1000000) example'); 288 | Cr{3,1} = '(3x3xN) *(3x3xN)'; 289 | A = rand(3,3,1000000); 290 | B = rand(3,3,1000000); 291 | % mtimes 292 | tm = zeros(1,n); 293 | for k=1:n 294 | clear Cm 295 | A(1) = 2*A(1); 296 | B(1) = 2*B(1); 297 | tic 298 | Cm = zeros(3,3,1000000); 299 | for k1=1:1000000 300 | Cm(:,:,k1) = A(:,:,k1) * B(:,:,k1); 301 | end 302 | tm(k) = toc; 303 | end 304 | % mtimesx 305 | tx = zeros(1,n); 306 | for k=1:n 307 | clear Cx 308 | tic 309 | Cx = mtimesx(A,B); 310 | tx(k) = toc; 311 | end 312 | % results 313 | tm = median(tm); 314 | tx = median(tx); 315 | if( tx < tm ) 316 | faster = sprintf('%7.1f',100*(tm)/tx-100); 317 | slower = ''; 318 | else 319 | faster = sprintf('%7.1f',-(100*(tx)/tm-100)); 320 | slower = ' (i.e., slower)'; 321 | end 322 | Cr{3,m} = faster; 323 | disp(' '); 324 | disp(['mtimes Elapsed time ' num2str(tm) ' seconds.']); 325 | disp(['MTIMESX Elapsed time ' num2str(tx) ' seconds.']); 326 | disp(['MTIMESX ' mtimesx ' mode is ' faster '% faster than MATLAB mtimes' slower]) 327 | if( isequal(Cx,Cm) ) 328 | disp(['MTIMESX ' mtimesx ' mode result matches mtimes: EQUAL']) 329 | else 330 | dx = max(abs(Cx(:)-Cm(:))); 331 | disp(['MTIMESX ' mtimesx ' mode result does not match mtimes: NOT EQUAL , max diff = ' num2str(dx)]) 332 | end 333 | 334 | disp(' '); 335 | disp('--------------------------------------------------------------'); 336 | disp('(real 2x2x2000000) * (real 2x2x2000000) example'); 337 | Cr{4,1} = '(2x2xN) *(2x2xN)'; 338 | A = rand(2,2,2000000); 339 | B = rand(2,2,2000000); 340 | % mtimes 341 | tm = zeros(1,n); 342 | for k=1:n 343 | clear Cm 344 | A(1) = 2*A(1); 345 | B(1) = 2*B(1); 346 | tic 347 | Cm = zeros(2,2,2000000); 348 | for k1=1:2000000 349 | Cm(:,:,k1) = A(:,:,k1) * B(:,:,k1); 350 | end 351 | tm(k) = toc; 352 | end 353 | % mtimesx 354 | tx = zeros(1,n); 355 | for k=1:n 356 | clear Cx 357 | tic 358 | Cx = mtimesx(A,B); 359 | tx(k) = toc; 360 | end 361 | % results 362 | tm = median(tm); 363 | tx = median(tx); 364 | if( tx < tm ) 365 | faster = sprintf('%7.1f',100*(tm)/tx-100); 366 | slower = ''; 367 | else 368 | faster = sprintf('%7.1f',-(100*(tx)/tm-100)); 369 | slower = ' (i.e., slower)'; 370 | end 371 | Cr{4,m} = faster; 372 | disp(' '); 373 | disp(['mtimes Elapsed time ' num2str(tm) ' seconds.']); 374 | disp(['MTIMESX Elapsed time ' num2str(tx) ' seconds.']); 375 | disp(['MTIMESX ' mtimesx ' mode is ' faster '% faster than MATLAB mtimes' slower]) 376 | if( isequal(Cx,Cm) ) 377 | disp(['MTIMESX ' mtimesx ' mode result matches mtimes: EQUAL']) 378 | else 379 | dx = max(abs(Cx(:)-Cm(:))); 380 | disp(['MTIMESX ' mtimesx ' mode result does not match mtimes: NOT EQUAL , max diff = ' num2str(dx)]) 381 | end 382 | 383 | disp(' '); 384 | disp('--------------------------------------------------------------'); 385 | disp('(real 2x2x2000000) * (real 1x1x2000000) example'); 386 | Cr{5,1} = '(2x2xN) *(1x1xN)'; 387 | A = rand(2,2,2000000); 388 | B = rand(1,1,2000000); 389 | % mtimes 390 | tm = zeros(1,n); 391 | for k=1:n 392 | clear Cm 393 | A(1) = 2*A(1); 394 | B(1) = 2*B(1); 395 | tic 396 | Cm = zeros(2,2,2000000); 397 | for k1=1:2000000 398 | Cm(:,:,k1) = A(:,:,k1) * B(:,:,k1); 399 | end 400 | tm(k) = toc; 401 | end 402 | % mtimesx 403 | tx = zeros(1,n); 404 | for k=1:n 405 | clear Cx 406 | tic 407 | Cx = mtimesx(A,B); 408 | tx(k) = toc; 409 | end 410 | % results 411 | tm = median(tm); 412 | tx = median(tx); 413 | if( tx < tm ) 414 | faster = sprintf('%7.1f',100*(tm)/tx-100); 415 | slower = ''; 416 | else 417 | faster = sprintf('%7.1f',-(100*(tx)/tm-100)); 418 | slower = ' (i.e., slower)'; 419 | end 420 | Cr{5,m} = faster; 421 | disp(' '); 422 | disp(['mtimes Elapsed time ' num2str(tm) ' seconds.']); 423 | disp(['MTIMESX Elapsed time ' num2str(tx) ' seconds.']); 424 | disp(['MTIMESX ' mtimesx ' mode is ' faster '% faster than MATLAB mtimes' slower]) 425 | if( isequal(Cx,Cm) ) 426 | disp(['MTIMESX ' mtimesx ' mode result matches mtimes: EQUAL']) 427 | else 428 | dx = max(abs(Cx(:)-Cm(:))); 429 | disp(['MTIMESX ' mtimesx ' mode result does not match mtimes: NOT EQUAL , max diff = ' num2str(dx)]) 430 | end 431 | 432 | try 433 | bsxfun(@times,1,1); 434 | Cr{6,1} = 'above vs bsxfun'; 435 | A = rand(2,2,2000000); 436 | B = rand(1,1,2000000); 437 | % bsxfun 438 | tm = zeros(1,n); 439 | for k=1:n 440 | clear Cm 441 | A(1) = 2*A(1); 442 | B(1) = 2*B(1); 443 | tic 444 | Cm = bsxfun(@times,A,B); 445 | tm(k) = toc; 446 | end 447 | % mtimesx 448 | tx = zeros(1,n); 449 | for k=1:n 450 | clear Cx 451 | tic 452 | Cx = mtimesx(A,B); 453 | tx(k) = toc; 454 | end 455 | % results 456 | tm = median(tm); 457 | tx = median(tx); 458 | if( tx < tm ) 459 | faster = sprintf('%7.1f',100*(tm)/tx-100); 460 | slower = ''; 461 | else 462 | faster = sprintf('%7.1f',-(100*(tx)/tm-100)); 463 | slower = ' (i.e., slower)'; 464 | end 465 | Cr{6,m} = faster; 466 | disp(' '); 467 | disp(['bsxfun Elapsed time ' num2str(tm) ' seconds.']); 468 | disp(['MTIMESX Elapsed time ' num2str(tx) ' seconds.']); 469 | disp(['MTIMESX ' mtimesx ' mode is ' faster '% faster than MATLAB bsxfun with @times' slower]) 470 | if( isequal(Cx,Cm) ) 471 | disp(['MTIMESX ' mtimesx ' mode result matches bsxfun with @times: EQUAL']) 472 | else 473 | dx = max(abs(Cx(:)-Cm(:))); 474 | disp(['MTIMESX ' mtimesx ' mode result does not match bsxfun with @times: NOT EQUAL , max diff = ' num2str(dx)]) 475 | end 476 | catch 477 | disp('Could not perform comparison with bsxfun, possibly because your version of'); 478 | disp('MATLAB does not have it. You can download a substitute for bsxfun from the'); 479 | disp('FEX here: http://www.mathworks.com/matlabcentral/fileexchange/23005-bsxfun-substitute'); 480 | end 481 | 482 | end 483 | 484 | disp(' '); 485 | disp('Percent Faster Results Table'); 486 | disp(' '); 487 | disp(Cr); 488 | 489 | disp(' '); 490 | disp('Done'); 491 | disp(' '); 492 | 493 | end 494 | --------------------------------------------------------------------------------