{"text": "function res = le(A,B)\n%LE Implements A<=B elementwise for long (refers only to midpoints)\n%\n\n% written 11/06/99 S.M. Rump\n% modified 04/04/04 S.M. Rump set round to nearest for safety\n% modified 04/06/05 S.M. Rump rounding unchanged\n%\n\n C = A - B;\n res = ( C.sign==-1 ) | all( C.mantissa==0 , 2);\n", "meta": {"author": "douthwja01", "repo": "OpenMAS", "sha": "962f321f82167db78066b2c88c783423ecc3b73a", "save_path": "github-repos/MATLAB/douthwja01-OpenMAS", "path": "github-repos/MATLAB/douthwja01-OpenMAS/OpenMAS-962f321f82167db78066b2c88c783423ecc3b73a/toolboxes/Intlab_V7.1/long/@long/le.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.7772998611746912, "lm_q2_score": 0.7718435083355187, "lm_q1q2_score": 0.5999538518777853}} {"text": "function list = shellSort(list)\n \n N = numel(list);\n increment = round(N/2);\n \n while increment > 0 %loop until increment becomes 0\n \n for i = (increment+1:N)\n temp = list(i);\n j = i;\n while (j >= increment+1) && (list(j-increment) > temp)\n list(j) = list(j-increment);\n j = j - increment;\n end\n \n list(j) = temp;\n \n end %for\n \n if increment == 2 %This case causes shell sort to become insertion sort\n increment = 1;\n else\n increment = round(increment/2.2);\n end \n end %while\nend %shellSort\n", "meta": {"author": "TheAlgorithms", "repo": "MATLAB-Octave", "sha": "e150b77ad256de46c1ce3815c3d7945ac4fc28dc", "save_path": "github-repos/MATLAB/TheAlgorithms-MATLAB-Octave", "path": "github-repos/MATLAB/TheAlgorithms-MATLAB-Octave/MATLAB-Octave-e150b77ad256de46c1ce3815c3d7945ac4fc28dc/algorithms/sorting/shell_sort.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7772998611746911, "lm_q2_score": 0.7718435083355187, "lm_q1q2_score": 0.5999538518777853}} {"text": "%% im2patch\n% Below is a demonstration of the features of the |im2patch| function\n\n%%\nclear; close all; clc;\n\n%% Syntax\n% |[F,V,C]=im2patch(M,IND,ptype);|\n\n%% Description\n% This function generates patch data for 3D images. The patch data is only\n% generated for the voxels specified by the indices (logic or linear\n% indices). The patch data is created according to the patch type desired\n% (e.g. voxel type of slice type).\n\n%% Examples\n\n%%\n% Plot settings\ncMap=parula(250);\nfaceAlpha1=1;\nfaceAlpha2=0.5;\nedgeColor1='none';\nedgeColor2='none';\nfontSize=15; \n\n%% Example: Introduction to using |im2patch| for voxel plotting\n% The voxel for which patch data is to be specified can be defined by\n% supplying linear indices or a logic array. \n\n% Simulating an image\nM=rand(3,5,7);\n% Example supplying linear indices, here all voxels\nindPatch=1:numel(M); \n\n%%\n% Creating patch data for voxel display\n[F,V,C]=im2patch(M,indPatch,'v'); \n\ncFigure;\ntitle('patch type: v');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\ngpatch(F,V,C,'k',faceAlpha2);\ncolormap(cMap); caxis([min(M(:)) max(M(:))]); colorbar; \naxisGeom(gca,fontSize); camlight headlight;\ndrawnow;\n\n%%\n% Study the size of the face and vertex arrays to confirm that the patch\n% type |'v'| creates vertices and faces for each voxel. Shared vertices and\n% faces are not removed. This option requires the most memory. \ndisp(num2str(size(F)));\ndisp(num2str(size(V)));\n\n%%\n% Creating patch data for voxel display with shared vertices and faces\n% removed\n[F,V,C]=im2patch(M,indPatch,'vu'); \n\ncFigure;\ntitle('patch type: vu');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\ngpatch(F,V,C,'k',faceAlpha2);\ncolormap(cMap); caxis([min(M(:)) max(M(:))]); colorbar; \naxisGeom(gca,fontSize); camlight headlight;\ndrawnow;\n\n%%\n% Study the size of the face and vertex arrays to confirm that the patch\n% type |'vu'| ensures that shared faces and vertices are not shared. Each\n% vertex and face is therefore unique. This saves memory with respect to\n% using the |'v'| patch type for voxel display. The figures look identical\n% except that shared faces may appear less dark when transparency is on\n% since now one one face is used. Color information is shared too\n% (averaged).\ndisp(num2str(size(F)));\ndisp(num2str(size(V)));\n\n%%\n% Creating patch data for voxel display with only non-shared faces and\n% vertices\n[F,V,C]=im2patch(M,indPatch,'vb'); \n\ncFigure;\ntitle('patch type: vb');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\ngpatch(F,V,C,'k',faceAlpha2);\ncolormap(cMap); caxis([min(M(:)) max(M(:))]); colorbar; \naxisGeom(gca,fontSize); camlight headlight;\ndrawnow;\n\n%%\n% Study the size of the face and vertex arrays to confirm that the patch\n% type |'vb'| helps to plot only non-shared vertices and faces. \n% In the case of an enclosed shape filled with voxels thus only the\n% boundary faces are displayed. This path type appears no different than\n% the other is transparency is not on however it is much lighter on memory\n% than the above path types. \ndisp(num2str(size(F)));\ndisp(num2str(size(V)));\n\n%% Example: Introduction to using |im2patch| for slice plotting\n\ncFigure;\ntitle('patch type: si, sj, sk');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\n\n%Setting up indices for I direction slices\nS=round(size(M,1)./2); %Selection of middle slice\nL_plot=false(size(M)); L_plot(S,:,:)=1;\nindPatch=find(L_plot);\n[F,V,C]=im2patch(M,indPatch,'si'); %Creating patch data for y mid-voxel slices\ngpatch(F,V,C);\n\n%Setting up indices for J direction slices\nS=round(size(M,2)./2); %Selection of middle slice\nL_plot=false(size(M)); L_plot(:,S,:)=1;\nindPatch=find(L_plot);\n[F,V,C]=im2patch(M,indPatch,'sj'); %Creating patch data for x mid-voxel slices\ngpatch(F,V,C);\n\n%Setting up indices for Z direction slices\nS=round(size(M,3)./2); %Selection of middle slice\nL_plot=false(size(M)); L_plot(:,:,S)=1;\nindPatch=find(L_plot);\n[F,V,C]=im2patch(M,indPatch,'sk'); %Creating patch data for z mid-voxel slices\ngpatch(F,V,C);\n\ncolormap(cMap); caxis([min(M(:)) max(M(:))]); colorbar; \naxisGeom(gca,fontSize); camlight headlight;\n\ndrawnow;\n\n%%\n% The path type s*u are simular to s* but use shared vertices\n\n%% Example: Comparison to standard MATLAB |imagesc| function and the patch type MATLAB functions |slice| and |pcolor|\n% The comparison is what motivates the choice of coordinate system for\n% im2patch i.e. that it is meant to aid in the visualization of image data\n% as is expected of image data. \n\ncFigure;\nsubplot(2,2,1);\ntitle('MATLAB imagesc function');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\nimagesc(M(:,:,S));\ncolormap(cMap); caxis([min(M(:)) max(M(:))]);\naxisGeom(gca,fontSize); view(2);\n\nsubplot(2,2,2);\ntitle('MATLAB slice function');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\nslice(M,[],[],S);\naxisGeom(gca,fontSize);\ncolormap(cMap); caxis([min(M(:)) max(M(:))]);\naxisGeom(gca,fontSize); view(2);\n\nsubplot(2,2,3);\ntitle('im2patch function');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\ngpatch(F,V,C);\ncolormap(cMap); caxis([min(M(:)) max(M(:))]);\naxisGeom(gca,fontSize); view(2);\n\nsubplot(2,2,4);\ntitle('MATLAB pcolor function');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\npcolor(M(:,:,S));\ncolormap(cMap); caxis([min(M(:)) max(M(:))]);\naxisGeom(gca,fontSize); view(2);\n\ndrawnow;\n\n%%\n% Note that the image size is wrong for the |slice| and |pcolor| commands.\n% This is because intensities appear to be defined on voxels vertices (and\n% are reinterpolated onto faces) for these functions instead of voxels\n% centres as should be the case for image data. \n\n%% Example: Creating and plotting combined voxel and slice patch data\n\n%%\n% Simulating 3D image\n[X,Y,Z]=meshgrid(linspace(-4.77,4.77,25));\nphi=(1+sqrt(5))/2;\nM=1/6*(2 - (cos(X + phi*Y) + cos(X - phi*Y) + cos(Y + phi*Z) + cos(Y - phi*Z) + cos(Z - phi*X) + cos(Z + phi*X)));\n\n%%\n% Creating and plotting patch data. Last example illustrates the use of a\n% specific logic description (i.e. a mask) for the voxels of interest\n\ncFigure;\ntitle('Combined voxel and slice plotting');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\n\n% Setting up indices for I direction slices\nS=round(size(M,1)./2); %Selection of middle slice\nL_plot=false(size(M)); L_plot(S,:,:)=1;\nindPatch=find(L_plot);\n[F,V,C]=im2patch(M,indPatch,'si'); %Creating patch data for y mid-voxel slices\ngpatch(F,V,C,'none',faceAlpha2);\n\n% Setting up indices for J direction slices\nS=round(size(M,2)./2); %Selection of middle slice\nL_plot=false(size(M)); L_plot(:,S,:)=1;\nindPatch=find(L_plot);\n[F,V,C]=im2patch(M,indPatch,'sj'); %Creating patch data for x mid-voxel slices\ngpatch(F,V,C,'none',faceAlpha2);\n\n% Setting up indices for K direction slices\nS=round(size(M,3)./2); %Selection of middle slice\nL_plot=false(size(M)); L_plot(:,:,S)=1;\nindPatch=find(L_plot);\n[F,V,C]=im2patch(M,indPatch,'sk'); %Creating patch data for z mid-voxel slices\ngpatch(F,V,C,'none',faceAlpha2);\n\n% Setting up indices for voxels to plot\nL_mask=M>-0.2 & M<0;\n[F,V,C]=im2patch(M,L_mask,'vb'); %Creating patch data for selection of high voxels\n\ngpatch(F,V,C);\ncolormap(cMap); colorbar; caxis([min(M(:)) max(M(:))]); \naxisGeom(gca,fontSize); camlight headlight;\ndrawnow;\n\n%% Example: Shrinking patch data through combination with |scalePatch| function\n\n% Using the function |scalePatch| patch data can be shrunk to aid\n% visualisation (can be a tool to avoid memory costly transparency for\n% instance).\n\n[Ev,Vv,Cv]=im2patch(M,L_mask,'h'); %This creates a hexahedral element for each voxel\n[Evs,Vvs]=scalePatch(Ev,Vv,0.5); %Apply voxel element scaling\n[Fvs,Cvs]=element2patch(Evs,Cv); %Convert to quad faces for plotting\n\n%%\n% Plotting the voxels\ncFigure;\ntitle('Scaled (shrunk) patch data');\nxlabel('J - columns');ylabel('I - rows'); zlabel('K - slices'); hold on;\ngpatch(Fvs,Vvs,Cvs);\ncolormap(cMap); colorbar; caxis([min(Cvs(:)) max(Cvs(:))]); \naxisGeom(gca,fontSize); camlight headlight;\ndrawnow;\n\n%% Example: Medical image data and coordinate manipulation due to voxel size\n\n% Get a 3D image\nload mri;\nM=squeeze(D); %example image data set\nv=2./[1,1,.4]; %example voxel size\n\n%%\n% The voxels to display can be specified as a list (vector) of voxels\n% numbers (linear indices) or using a mask (logic array).\n\n%Defining row, column and slice indicices for slice patching\nsliceIndexI=round(size(M,1)/2); %(close to) middle row\nsliceIndexJ=round(size(M,2)/2); %(close to) middle column\nsliceIndexK=round(size(M,3)/2); %(close to) middle slice\n\n%Defining \"masks\" i.e. logic arrays with ones for voxels of interest\nlogicSliceI=false(size(M)); \nlogicSliceI(sliceIndexI,:,:)=1;\nlogicSliceI=logicSliceI & M>0;\n\nlogicSliceJ=false(size(M)); \nlogicSliceJ(:,sliceIndexJ,:)=1;\nlogicSliceJ=logicSliceJ & M>0;\n\nlogicSliceK=false(size(M)); \nlogicSliceK(:,:,sliceIndexK)=1;\nlogicSliceK=logicSliceK & M>0;\n\n%Defining voxel indices for voxels of interest\nT_low=min(M(:))+((max(M(:))-min(M(:)))/10); %Threshold example\nlogicVoxels=(M>T_low);\nlogicVoxels(:,1:sliceIndexJ,:)=0;\n\n%%\n% Creating patch data\n% The patch data consists of a matrix array defining the faces, a matrix\n% array defining the vertices and a vector for the colour data. The\n% vertices are based on the image coordinates however they are formatted\n% as: [X(:) Y(:) Z(:)]. X relates to columns, Y to rows and Z to slices. \n% Use a function like |im2cart| , or |im2mrcart| to convert image to cartesian\n% coordinates. \n \n[Fv,Vv,Cv]=im2patch(M,logicVoxels,'vb'); \n[Fx,Vx,Cx]=im2patch(M,logicSliceJ,'sj');\n[Fy,Vy,Cy]=im2patch(M,logicSliceI,'si');\n[Fz,Vz,Cz]=im2patch(M,logicSliceK,'sk');\n\n% Convert image coordinates to cartesian coordinates\n[Vv(:,1),Vv(:,2),Vv(:,3)]=im2cart(Vv(:,2),Vv(:,1),Vv(:,3),v); \n[Vx(:,1),Vx(:,2),Vx(:,3)]=im2cart(Vx(:,2),Vx(:,1),Vx(:,3),v);\n[Vy(:,1),Vy(:,2),Vy(:,3)]=im2cart(Vy(:,2),Vy(:,1),Vy(:,3),v);\n[Vz(:,1),Vz(:,2),Vz(:,3)]=im2cart(Vz(:,2),Vz(:,1),Vz(:,3),v);\n\n%%\n% \ncFigure;\ntitle('MRI visualisation, slices and voxels in cartesian coordinates with aid of voxel size');\nxlabel('X (mm)');ylabel('Y (mm)'); zlabel('Z (mm)'); hold on;\ngpatch(Fv,Vv,Cv,edgeColor1,faceAlpha2);\ngpatch(Fx,Vx,Cx,edgeColor1,faceAlpha1);\ngpatch(Fy,Vy,Cy,edgeColor1,faceAlpha1);\ngpatch(Fz,Vz,Cz,edgeColor1,faceAlpha1);\ncolormap(gray(250)); colorbar; \naxisGeom(gca,fontSize); camlight headlight;\ndrawnow;\n\n%% Example: Combining colormap and RGB driven patch colours \n% N.B. The figure renderer might have to be set to OPENGL.\n\n%%\n% Convert voxels colouring to RGB type, here a simple conversion to a gray\n% scale description is used\nCv=(Cv*ones(1,3))./max(Cv(:)); \n\n%%\n% Plotting the voxels\n\ncFigure;\ntitle('MRI visualisation, slices and voxels, colormap and RGB driven respectively');\nxlabel('X (mm)');ylabel('Y (mm)'); zlabel('Z (mm)'); hold on;\n\n%RGB driven\ngpatch(Fv,Vv,Cv,edgeColor1,faceAlpha2);\n\n%Colormap driven\ngpatch(Fx,Vx,Cx,edgeColor1,faceAlpha1);\ngpatch(Fy,Vy,Cy,edgeColor1,faceAlpha1);\ngpatch(Fz,Vz,Cz,edgeColor1,faceAlpha1);\n\ncolormap(cMap); colorbar; \naxisGeom(gca,fontSize); camlight headlight;\ndrawnow;\n\n%% \n%\n% <>\n% \n% _*GIBBON*_ \n% \n% \n% _Kevin Mattheus Moerman_, \n \n%% \n% _*GIBBON footer text*_ \n% \n% License: \n% \n% GIBBON: The Geometry and Image-based Bioengineering add-On. A toolbox for\n% image segmentation, image-based modeling, meshing, and finite element\n% analysis.\n% \n% Copyright (C) 2006-2022 Kevin Mattheus Moerman and the GIBBON contributors\n% \n% This program is free software: you can redistribute it and/or modify\n% it under the terms of the GNU General Public License as published by\n% the Free Software Foundation, either version 3 of the License, or\n% (at your option) any later version.\n% \n% This program is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU General Public License for more details.\n% \n% You should have received a copy of the GNU General Public License\n% along with this program. If not, see .\n", "meta": {"author": "gibbonCode", "repo": "GIBBON", "sha": "8178520664a6148db939eaea87e75b3cba4f2b4f", "save_path": "github-repos/MATLAB/gibbonCode-GIBBON", "path": "github-repos/MATLAB/gibbonCode-GIBBON/GIBBON-8178520664a6148db939eaea87e75b3cba4f2b4f/docs/HELP_im2patch.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7718434873426302, "lm_q2_score": 0.7772998714925403, "lm_q1q2_score": 0.5999538435237807}} {"text": "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n%\n% evalIFGT Evaluate the density estimate using the \"improved\" Fast Gauss Transform\n%\n% [e,b] = evalIFGT(X,Y,N [,Nc,rC]) -- eval likelihood (\"e\") of the points Y under\n% the density estimate X using N coefficients of the\n% \"improved\" Fast Gauss Transform; the value \"b\" is the bound\n% on the (absolute) error which could arise.\n%\n% Optional arguments:\n% Nc -- # of clusters to use for \"X\", default is sqrt(Npoints) \n% rC -- Cutoff radius (in std deviations) to exclude contributions, default 3\n%\n% See: Yang, Duraiswami, Gumerov; \"Improved Fast Gauss Transform\", submitted to \n% the Siam Journal of Scientific Computing, 2004\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\nfunction [estimate,errbound] = evalIFGT(pp,q,Ncoeff,Nclusters,rCutoff)\n p = kde(pp);\t% copy constructor to dodge later rescaling...\n if (p.type ~= 0) \n error('Sorry -- FGT = fast Gauss transform; it needs Gaussian kernels');\n end;\n if (size(p.bandwidth,2)>2*p.N)\n error('Sorry -- IFGT currently supports only uniform bandwidths');\n end;\n if (nargin<4) Nclusters = round(sqrt(getNpts(p))); end;\n if (nargin<5) rCutoff = 3; end; \n if (isa(q,'kde')) qpts = getPoints(q); else qpts = q; end;\n \n BW = getBW(p,1); BWorig = BW;\n if (any( BW - BW(1) )) % CONVERT TO SINGLE, SCALAR BW:\n p = rescale(p, 1./BW); % if differ in dimensions, need to rescale\n qpts = qpts .* repmat(1./BW,[1,size(qpts,2)]);\n BW = 1;\n else BW = BW(1); % already scalar; can just drop other dim's\n end;\n\n [c,cPts,cWts,cWt,cRad] = fpClusterK(p,Nclusters);\n %[c,cPts,cWts,cWt,cRad] = fpClusterR(p,sqrt(2)*BW);\n coeff = findCoeff(c,cPts,cWts,cRad,BW,Ncoeff);\n [estimate,errbound] = evalCoeff( qpts, c,coeff,Ncoeff,cWt,BW,cRad,rCutoff);\n\n % Change norm. constant (due to rescaling operation)\n scale = p.D*log(BW) - sum(log(BWorig));\n estimate = estimate * exp(scale); errbound = errbound * exp(scale);\n\n\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% fpCluster -- fast, \"farthest point\" clustering method\n% cluster points of \"p\" into K clusters, described by \"centers\",\n% \"clusters\" (cell array of pts to each cluster),\n% cWeight (weight per cluster), and maximum radius of any cluster.\n%\nfunction [centers, clusters, weights, cWeight, radius] = fpClusterK(p, K)\n points = getPoints(p); wts = getWeights(p);\n [D,N] = size(points);\n centers = zeros(D,K); clusters = cell(1,K); weights = cell(1,K);\n assign = ones(1,N); dmin = zeros(1,N)+inf;\n next = fix(rand(1)*N)+1; % choose 1st center at random\n for i=1:K\n centers(:,i) = points(:, next);\n d = points - repmat(centers(:,i),[1,N]);\n d = sqrt(sum(d.^2,1));\n F=find(d rMax),\n i=i+1; centers(:,i) = points(:, next);\n d = points - repmat(centers(:,i),[1,N]);\n d = sqrt(sum(d.^2,1));\n F=find(d= rCutoff^2);\n\n start = 0; startNew = 1;\n terms = zeros(length(PTS),size(coeffI,2));\n terms(:,start+1) = exp( - distance2(PTS) )';\n pos = ones(1,D); \n for j=2:Nterms\n Nprev = startNew - start;\n\tNadd = sum(Nprev-pos+1); \n\tm=1; posNew(1)=m;\n\tfor k=1:D\n\t for l=pos(k):Nprev\n\t terms(:,startNew+m) = vals(k,PTS)' .* terms(:,start+l);\n\t m = m+1;\n\t end;\n\t if (k~=D) posNew(k+1) = m; end;\n\tend;\n\tpos = posNew; start = startNew; startNew = start+Nadd;\n end;\n est(PTS) = est(PTS) + (coeffI * terms');\n\n % error bound addition for included points... + Qin * 2^p/p! rhox^p rhoy^p\n err(PTS)=err(PTS) + cWt(i)*exp( Nterms*log(2*rCutoff)- sum(log(1:Nterms)) + Nterms*log(cRad/h) );\n\n % error bound addition for excluded points... + Qin * exp(-rhoy^2+rhox^2)\n err(PTSN)=err(PTSN) + cWt(i)*exp( - rCutoff^2 + (cRad/h)^2 );\n\n end; \n h = h / sqrt(2);\n \n est = est ./ (2*pi*h^2)^(D/2);\n err = err ./ (2*pi*h^2)^(D/2);\n\n", "meta": {"author": "ShapeNet", "repo": "RenderForCNN", "sha": "c0bee04aad3dc2f0ae5de71daf6d51664ce02e76", "save_path": "github-repos/MATLAB/ShapeNet-RenderForCNN", "path": "github-repos/MATLAB/ShapeNet-RenderForCNN/RenderForCNN-c0bee04aad3dc2f0ae5de71daf6d51664ce02e76/render_pipeline/kde/matlab_kde_package/evalIFGT.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127492339909, "lm_q2_score": 0.7025300698514777, "lm_q1q2_score": 0.5998993833664229}} {"text": "classdef factorize\n%FACTORIZE an object-oriented method for solving linear systems\n% and least-squares problems, and for representing operations with the\n% inverse of a square matrix or the pseudo-inverse of a rectangular matrix.\n%\n% F = factorize(A) returns an object F that holds the factorization of a\n% non-singular matrix A. x=F\\b then solves a linear system or a\n% least-squares problem. S=inverse(F) or S=inverse(A) returns a factorized\n% representation of the inverse of A so that inverse(A)*b is mathematically\n% equivalent to inv(A)*b, but the former does not actually compute the\n% inverse of A.\n%\n% Example\n%\n% F = factorize(A) ; % LU, QR, or Cholesky factorization of A\n% x = F\\b ; % solve A*x=b; same as x=A\\b\n% S = inverse (F) ; % S represents the factorization of inv(A)\n% x = S*b ; % same as x = A\\b.\n% S = A-B*inverse(D)*C % efficiently computes the Schur complement\n% S = A-B*inv(D)*C % bad method for computing the Schur complement\n% S = inverse(A) ; S(:,1) % compute just the first column of inv(A),\n% % without computing inv(A)\n%\n% If A is square, symmetric (Hermitian for the complex case), and has a\n% real positive diagonal, then use F=factorize(A,1). If you know\n% otherwise, use F=factorize(A,0). Using this option improves performance,\n% since otherwise this condition must be checked to choose between a\n% Cholesky or LU factorization. The option is ignored if A is rectangular.\n%\n% For more details, type \"help factorize1\".\n% For a demo type \"fdemo\" or see the html/ directory.\n%\n% See also inverse, factorize1, mldivide, mrdivide, inv, pinv, linsolve\n\n% Copyright 2009, Timothy A. Davis, University of Florida\n\n properties (SetAccess = protected)\n % The factorize object holds a QR, LU, Cholesky factorization:\n A = [ ] ; % a copy of the input matrix\n L = [ ] ; % lower-triangular factor for LU and Cholesky\n U = [ ] ; % upper-triangular factor for LU\n Q = [ ] ; % Q factor for dense QR\n R = [ ] ; % R factor for QR\n p = [ ] ; % sparse row permutation matrix\n q = [ ] ; % sparse column permutation matrix\n is_inverse = false ; % F represents the factorization of A or inv(A)\n kind = 0 ; % F is one of 8 kinds of factorizations\n end\n\n methods\n\n function F = factorize (A,try_chol)\n\n % factorize constructor: compute a factorization of A\n\n if (ndims (A) > 2)\n error ('Matrix must be 2D.') ;\n end\n [m n] = size (A) ;\n F.A = A ;\n\n if (m > n)\n\n % QR factorization of A\n if (issparse (A))\n % Q-less econonmy sparse QR: (A*q)'*(A*q) = R'*R\n q = sparse (colamd (A), 1:n, 1) ;\n R = qr (A*q, 0) ;\n F.q = q ;\n F.kind = 1 ;\n else\n % dense economy QR factorization: A = Q*R\n [Q R] = qr (A,0) ;\n F.Q = Q ;\n F.kind = 2 ;\n end\n ok = (nnz (diag (R)) == n) ;\n F.R = R ;\n\n elseif (m < n)\n\n % QR factorization of A'\n if (issparse (A))\n % Q-less economy sparse QR: (p*A)*(p*A)' = R'*R\n C = A' ;\n p = sparse (1:m, colamd (C), 1) ;\n R = qr (C*p', 0) ;\n F.p = p ;\n F.kind = 3 ;\n else\n % dense economy LQ factorization: A' = Q*R\n [Q R] = qr (A',0) ;\n F.Q = Q ;\n F.kind = 4 ;\n end\n ok = (nnz (diag (R)) == m) ;\n F.R = R ;\n\n else\n\n % Cholesky or LU factorization of A\n g = 1 ;\n if (nargin == 1)\n % This is an expensive test, so skip it if the caller\n % already knows the matrix is a candidate for Cholesky.\n d = diag (A) ;\n try_chol = (all (d > 0) && nnz (imag (d)) == 0 && ...\n nnz (A-A') == 0) ;\n end\n if (try_chol)\n if (issparse (A))\n % sparse Cholesky factorization: q'*A*q = L*L'\n [L g q] = chol (A, 'lower') ;\n else\n % dense Cholesky factorization: A = R'*R\n [R g] = chol (A) ;\n end\n end\n % do an LU factorization if Cholesky failed or was skipped\n ok = (g == 0) ;\n if (ok)\n % Cholesky was successful\n if (issparse (A))\n F.L = L ;\n F.q = q ;\n F.kind = 5 ;\n else\n F.R = R ;\n F.kind = 6 ;\n end\n else\n % need an LU factorization\n if (issparse (A))\n % sparse LU factorization: p*A*q = L*U\n [L U p q] = lu (A) ;\n F.q = q ;\n F.kind = 7 ;\n else\n % dense LU factorization: p*A = L*U\n [L U p] = lu (A, 'vector') ;\n p = sparse (1:n, p, 1) ;\n F.kind = 8 ;\n end\n F.L = L ;\n F.U = U ;\n F.p = p ;\n ok = (nnz (diag (U)) == n) ;\n end\n end\n\n if (~ok)\n error ('Matrix is rank deficient.') ;\n end\n end\n end\nend\n\n", "meta": {"author": "fieldtrip", "repo": "fieldtrip", "sha": "c2039be598a02d86b39aae76bfa7aaa720f9801c", "save_path": "github-repos/MATLAB/fieldtrip-fieldtrip", "path": "github-repos/MATLAB/fieldtrip-fieldtrip/fieldtrip-c2039be598a02d86b39aae76bfa7aaa720f9801c/external/dmlt/external/gpstuff/SuiteSparse/MATLAB_Tools/Factorize/@factorize/factorize.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8539127603871312, "lm_q2_score": 0.702530051167069, "lm_q1q2_score": 0.5998993752469844}} {"text": "function [textures] = getGLSZMtextures_temp(GLSZM)\n% -------------------------------------------------------------------------\n% function [textures] = getGLSZMtextures_temp(GLSZM)\n% -------------------------------------------------------------------------\n% DESCRIPTION:\n% This function computes texture features from an input Gray-Level Size\n% Zone Matrix (GLSZM).\n% -------------------------------------------------------------------------\n% REFERENCES:\n% [1] Galloway, M. M. (1975). Texture analysis using gray level run lengths. \n% Computer Graphics and Image Processing, 4(2), 172\u2013179.\n% [2] Chu, A., Sehgal, C. M., & Greenleaf, J. F. (1990). Use of gray value \n% distribution of run lengths for texture analysis. Pattern Recognition\n% Letters, 11(6), 415-419.\n% [3] Dasarathy, B. V., & Holder, E. B. (1991). Image characterizations \n% based on joint gray level-run length distributions. Pattern \n% Recognition Letters, 12(8), 497-502.\n% [4] Thibault, G., Fertil, B., Navarro, C., Pereira, S., Cau, P., Levy, \n% N., Mari, J.-L. (2009). Texture Indexes and Gray Level Size Zone \n% Matrix. Application to Cell Nuclei Classification. In Pattern \n% Recognition and Information Processing (PRIP) (pp. 140\u2013145).\n% -------------------------------------------------------------------------\n% INPUTS:\n% - GLSZM: Gray-Level Size Zone Matrix.\n%\n% ** 'GLSZM' should be the output from 'getGLSZM.m' **\n% -------------------------------------------------------------------------\n% OUTPUTS:\n% - textures: Struture specifying the values of different GLSZM texture\n% features as defined below.\n% -------------------------------------------------------------------------\n% AUTHOR(S): Martin Vallieres \n% -------------------------------------------------------------------------\n% HISTORY:\n% - Creation: January 2013\n% - Revision: May 2015\n% -------------------------------------------------------------------------\n% STATEMENT:\n% This file is part of , \n% a package providing MATLAB programming tools for radiomics analysis.\n% --> Copyright (C) 2015 Martin Vallieres\n%\n% This package is free software: you can redistribute it and/or modify\n% it under the terms of the GNU General Public License as published by\n% the Free Software Foundation, either version 3 of the License, or\n% (at your option) any later version.\n%\n% This package is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU General Public License for more details.\n%\n% You should have received a copy of the GNU General Public License\n% along with this package. If not, see .\n% -------------------------------------------------------------------------\n\n\n% USEFUL MATRICES, VECTORS AND QUANTITIES\nsz = size(GLSZM); % Size of GLSZM\nnRuns = sum(GLSZM(:));\ncVect = 1:sz(2); rVect = 1:sz(1);% Row and column vectors\n[cMat,rMat] = meshgrid(cVect,rVect); % Column and row indicators for each entry of the GLSZM\npg = sum(GLSZM,2)'; % Gray-Level Run-Number Vector\npr = sum(GLSZM); % Run-Length Run-Number Vector\n\n\n% COMPUTATION OF TEXTURE FEATURES\n% 1. Small Zone Emphasis (SZE), Ref.[1,4]\ntextures.SZE = (pr*(cVect.^(-2))')/nRuns;\n\n% 2. Large Zone Emphasis (LZE), Ref.[1,4]\ntextures.LZE = (pr*(cVect.^2)')/nRuns;\n\n% 3. Gray-Level Nonuniformity (GLN), adapted from Ref.[1,4]\ntextures.GLN = sum(pg.^2)/nRuns;\n\n% 4. Zone-Size Nonuniformity (ZSN), adapted from Ref.[1,4]\ntextures.ZSN = sum(pr.^2)/nRuns;\n\n% 5. Zone Percentage (ZP), adapted from Ref.[1,4]\ntextures.ZP = nRuns/(pr*cVect');\n\n% 6. Low Gray-Level Zone Emphasis (LGZE), Ref.[2,4]\ntextures.LGZE = (pg*(rVect.^(-2))')/nRuns;\n\n% 7. High Gray-Level Zone Emphasis (HGZE), Ref.[2,4]\ntextures.HGZE = (pg*(rVect.^2)')/nRuns;\n\n% 8. Small Zone Low Gray-Level Emphasis (SZLGE), Ref.[3,4]\ntextures.SZLGE = sum(sum(GLSZM.*(rMat.^(-2)).*(cMat.^(-2))))/nRuns;\n\n% 9. Small Zone High Gray-Level Emphasis (SZHGE), Ref.[3,4]\ntextures.SZHGE = sum(sum(GLSZM.*(rMat.^2).*(cMat.^(-2))))/nRuns;\n\n% 10. Large Zone Low Gray-Level Emphasis (LZLGE), Ref.[3,4]\ntextures.LZLGE = sum(sum(GLSZM.*(rMat.^(-2)).*(cMat.^2)))/nRuns;\n\n% 11. Large Zone High Gray-Level Emphasis (LZHGE), Ref.[3,4]\ntextures.LZHGE = sum(sum(GLSZM.*(rMat.^2).*(cMat.^2)))/nRuns;\n\n\n% New features according to Ref.[4]\n% GLSZM = GLSZM./nRuns; % In the future, this operation will be applied at the beginning of the function\n% pg=sum(GLSZM,2)'; pr=sum(GLSZM);\nug = (pg*rVect')/(sz(1)*sz(2));\nur = (pr*cVect')/(sz(1)*sz(2));\n\n% 12. Gray-Level Variance (GLV), adapted from Ref.[4]\nGLV = 0;\nfor g = 1:sz(1)\n for r = 1:sz(2)\n GLV = GLV + (GLSZM(g,r)*g-ug)^2;\n end\nend\ntextures.GLV = GLV/(sz(1)*sz(2));\n\n% 13. Zone-Size Variance (ZSV), adapted from Ref.[4]\nZSV = 0;\nfor g = 1:sz(1)\n for r = 1:sz(2)\n ZSV = ZSV + (GLSZM(g,r)*r-ur)^2;\n end\nend\ntextures.ZSV = ZSV/(sz(1)*sz(2));\n\nend", "meta": {"author": "mvallieres", "repo": "radiomics", "sha": "d3a61737730e1b2b46d04c9e22a3fcc390912f1a", "save_path": "github-repos/MATLAB/mvallieres-radiomics", "path": "github-repos/MATLAB/mvallieres-radiomics/radiomics-d3a61737730e1b2b46d04c9e22a3fcc390912f1a/STUDIES/HN_study/Functions/FEATURES_COMPUTATIONS/getGLSZMtextures_temp.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.853912760387131, "lm_q2_score": 0.702530051167069, "lm_q1q2_score": 0.5998993752469843}} {"text": "function G=gauss2dmultislice(sizevec, m, s, a)\n% G=gauss2dmultislice(sizevec, m, s, a)\nlm=length(m);\nif length(s)\n% * \n% * \n%\n\n%% Description\n%\n% You can find expanded version of this example\n% .\n%\n% We are going to use images 1 and 3 from _Graffity_ sequence of Oxford\n% dataset.\n%\n% <>\n%\n% Homography is given by a 3-by-3 matrix shown below.\n%\n\n%% Code\n% Options\ninlier_threshold = 2.5; % Distance threshold to identify inliers\nnn_match_ratio = 0.8; % Nearest neighbor\n\n%%\n% Load grayscale images\nfnames = {\n fullfile(mexopencv.root(), 'test', 'graf1.png')\n fullfile(mexopencv.root(), 'test', 'graf3.png')\n};\nimgs = cell(size(fnames));\nfor i=1:numel(fnames)\n % downloading if necessary\n if exist(fnames{i}, 'file') ~= 2\n disp('Downloading image...')\n [~,name,ext] = fileparts(fnames{i});\n baseURL = 'https://cdn.rawgit.com/opencv/opencv/3.2.0/samples/data/';\n urlwrite([baseURL, name, ext], fnames{i});\n end\n % read image\n imgs{i} = cv.imread(fnames{i}, 'Grayscale',true);\nend\n[img1, img2] = deal(imgs{:});\nwhos img1 img2\n\n%%\n% ground-truth homography\nH = [\n 7.6285898e-01 -2.9922929e-01 2.2567123e+02\n 3.3443473e-01 1.0143901e+00 -7.6999973e+01\n 3.4663091e-04 -1.4364524e-05 1.0000000e+00\n];\ndisplay(H)\n\n%%\n% Detect keypoints and compute descriptors using AKAZE\nif true\n name = 'AKAZE';\n akaze = cv.AKAZE();\n [kpts1, desc1] = akaze.detectAndCompute(img1);\n [kpts2, desc2] = akaze.detectAndCompute(img2);\nelse\n % requires xfeatures2d from opencv_contrib\n name = 'LATCH';\n orb = cv.ORB('MaxFeatures',10000);\n kpts1 = orb.detect(img1);\n kpts2 = orb.detect(img2);\n latch = cv.LATCH();\n desc1 = latch.compute(img1, kpts1);\n desc2 = latch.compute(img2, kpts2);\nend\nwhos kpts1 kpts2 desc1 desc2\n\n%%\n% Use brute-force matcher to find 2-nn matches.\n% We use Hamming distance, because AKAZE uses binary descriptor by default.\nmatcher = cv.DescriptorMatcher('BruteForce-Hamming');\nmatches = matcher.knnMatch(desc1, desc2, 2);\nwhos matches\n\n%%\n% Use 2-nn matches to find correct keypoint matches.\n% If the closest match is |ratio| closer than the second closest one, then the\n% match is correct.\nidx = cellfun(@(m) m(1).distance < nn_match_ratio * m(2).distance, matches);\nmatches = cellfun(@(m) m(1), matches(idx));\nkp1 = kpts1([matches.queryIdx] + 1);\nkp2 = kpts2([matches.trainIdx] + 1);\nwhos matches kp1 kp2\n\n%%\n% Check if our matches fit in the homography model.\n% If the distance from first keypoint's projection to the second keypoint\n% is less than threshold, then it it fits in the homography.\npts1 = cat(1, kp1.pt);\npts1(:,3) = 1;\npts1 = (H * pts1.').';\npts1 = bsxfun(@rdivide, pts1(:,1:2), pts1(:,3));\npts2 = cat(1, kp2.pt);\nd = sqrt(sum((pts1 - pts2).^2, 2));\nidx = d < inlier_threshold;\nwhos pts1 pts2\nfprintf('%d inliers\\n', nnz(idx));\n\n%%\n% We create a new set of matches for the inliers, because it is required\n% by the drawing function.\nkp1_good = kp1(idx);\nkp2_good = kp2(idx);\nmatches_good = matches(idx);\nfor i=1:numel(matches_good)\n matches_good(i).queryIdx = i-1;\n matches_good(i).trainIdx = i-1;\nend\nwhos kp1_good kp2_good matches_good\n\n%%\n% Show the result\nres = cv.drawMatches(img1, kp1_good, img2, kp2_good, matches_good);\nimshow(res), title(name)\n\n%%\n% Print some statistics\nfprintf('%s Matching Results:\\n', name);\nfprintf('Keypoints 1: %d\\n', numel(kpts1));\nfprintf('Keypoints 2: %d\\n', numel(kpts2));\nfprintf('Matches: %d\\n', numel(matches));\nfprintf('Inliers: %d\\n', numel(matches_good));\nfprintf('Inliers Ratio: %f\\n', numel(matches_good) / numel(matches));\n\n%% References\n%\n% * *(AKAZE)* Pablo F Alcantarilla, Jesus Nuevo, and Adrien Bartoli. \"Fast\n% explicit diffusion for accelerated features in nonlinear scale spaces\".\n% Trans. Pattern Anal. Machine Intell, 34(7):1281-1298, 2011.\n% * *(LATCH)* Gil Levi and Tal Hassner, \"LATCH: Learned Arrangements of\n% Three Patch Codes\", arXiv preprint arXiv:1501.03719, 15 Jan. 2015\n%\n", "meta": {"author": "kyamagu", "repo": "mexopencv", "sha": "d29007b2a484d0fd92e6e941dc5fd4750014fa6a", "save_path": "github-repos/MATLAB/kyamagu-mexopencv", "path": "github-repos/MATLAB/kyamagu-mexopencv/mexopencv-d29007b2a484d0fd92e6e941dc5fd4750014fa6a/samples/akaze_match_demo.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7799929002541068, "lm_q2_score": 0.76908023177796, "lm_q1q2_score": 0.5998771205125918}} {"text": "function [max_min_diff, total_max_min_diff] = minimax(M)\n max_rows = max(M');\n min_rows = min(M');\n max_min_diff = max_rows - min_rows;\n total_max_min_diff = max(max_rows) - min(min_rows);\nend\n", "meta": {"author": "anishLearnsToCode", "repo": "introduction-to-programming-with-matlab", "sha": "4eb0dfab3f41b8a20d890e8d01a9e9b7463de410", "save_path": "github-repos/MATLAB/anishLearnsToCode-introduction-to-programming-with-matlab", "path": "github-repos/MATLAB/anishLearnsToCode-introduction-to-programming-with-matlab/introduction-to-programming-with-matlab-4eb0dfab3f41b8a20d890e8d01a9e9b7463de410/week-5/minimax.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8311430478583168, "lm_q2_score": 0.7217432122827968, "lm_q1q2_score": 0.5998718532277759}} {"text": "function [ftlb] = Btu2ftlb(Btu)\n% Convert energy or work from British thermal units to foot-pounds.\n% Chad A. Greene 2012\nftlb = Btu*778.16932495 ;", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/35258-unit-converters/unit_converters/Btu2ftlb.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8311430478583168, "lm_q2_score": 0.7217432003123989, "lm_q1q2_score": 0.5998718432786629}} {"text": "function Iout=scorfilt(I)\n% SPATIAL CORRELATION FILTER\n% \n% IN\n% I: Image to filter, (RGB color or grayscale)\n% %\n% OUT\n% Iout: Filtered image (double)\n%\n% EXAMPLE:\n%\n% %read image\n% imfile = fullfile(matlabroot,...\n% 'toolbox','images','imdemos','greens.jpg');\n% Io=im2double(imread(imfile));\n% %add noise\n% sigma_n=20; %noise std. dev.\n% randn('seed', 0);\n% I=Io+sigma_n/255*randn(size(Io));\n% figure('Name', 'input'), imshow(I);\n% %filter image\n% Iout = scorfilt(I);\n% figure('Name', 'output'), imshow(Iout);\n%\n% Author: Carlos Estrada\n% Date: May 25, 2012\n% Version 1.0\n%\n%% Configuration\nr_max=5; %max. half-size window\nc=1/5; %c 'neighborhood' constant default value\n\n%% labels\nI=im2double(I);\n[m n ch]=size(I);\n \nif ch==1 %gray scale\n maxI=max(I(:));\n minI=min(I(:));\n bins=255; %quantization bins \n Ieq=uint8((bins-1)*histeq((I-minI)./(maxI-minI), bins))+1;\n\n labels=zeros(m,n,'uint8');\n N=0;\n bin_mark=zeros(bins,1,'uint8');\n\n for i=1:m \n for j=1:n \n id=Ieq(i,j);\n if bin_mark(id)==0\n N=N+1;\n labels(i,j)=N;\n bin_mark(id)=N;\n else\n labels(i,j)=bin_mark(id);\n end\n end\n end\n\nelseif ch==3 %color\n% maxI=max(I(:));\n% minI=min(I(:));\n% Ifit=(I-minI)/(maxI-minI);\n bins=255; %quantization bins\n [labels, centers] = rgb2ind(I,bins,'nodither');\n N=size(centers,1);\n labels=labels+1;\nend\n\n%% adjacency matrix\nAcum=zeros(N,'uint32');\nfor i=1:m\n for j=1:n\n a=labels(i,j);\n if i>1\n e=labels(i-1,j);\n Acum(a,e)=Acum(a,e)+1;\n end\n if j>1\n e=labels(i,j-1);\n Acum(a,e)=Acum(a,e)+1;\n end\n end\nend\nA=double(Acum+Acum');\n\nh4=sum(A,2);\nP=A./repmat(h4,1,N); %transition matrix\nQ=((P+P')./2)^2;\n%% neighborhood size\nteta=diag(P)'*h4./sum(h4);\nw=sqrt((1-teta)/teta);\nsigma_d=c*w;\nr=max(1,min(r_max,round(sigma_d*2.5)));\n%fprintf('\\tN: %d\\tw: %.4f\\tsigma_d: %.4f', N,w,sigma_d);\n%% compute Iout\nIout=zeros(m,n,ch);\n[x,y] = meshgrid(-r:r,-r:r);\nF=exp(-(x.^2 + y.^2)./(2*sigma_d^2));\n\nfor i=1:m \n iMin = max(i-r,1);\n iMax = min(i+r,m);\n di=iMin:iMax;\n for j=1:n \n jMin = max(j-r,1);\n jMax = min(j+r,n);\n dj=jMin:jMax;\n \n a=labels(i,j);\n l = labels(di,dj);\n f=F(di-i+r+1,dj-j+r+1);\n \n w=Q(l(:),a).*f(:);\n w=w./sum(w);\n \n y=I(di,dj,:);\n \n for cc=1:ch\n yc=y(:,:,cc);\n Iout(i,j,cc)=w'*yc(:);\n end\n end\nend\n", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/39150-image-filter-by-spatial-correlation/scorfilt.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.831143031127974, "lm_q2_score": 0.721743200312399, "lm_q1q2_score": 0.5998718312036518}} {"text": "function d = fd04 ( p )\n\n%*****************************************************************************80\n%\n%% FD04 is a signed distance function for problem 4.\n%\n% Modified:\n%\n% 11 September 2005\n%\n% Parameters:\n%\n% Input, real P(N,3), one or more points.\n%\n% Output, real D(N), the signed distance of each point to the boundary of the region.\n%\n d = sqrt ( sum ( p .^ 2, 2 ) ) - 1.0;\n\n return\nend\n", "meta": {"author": "johannesgerer", "repo": "jburkardt-m", "sha": "1726deb4a34dd08a49c26359d44ef47253f006c1", "save_path": "github-repos/MATLAB/johannesgerer-jburkardt-m", "path": "github-repos/MATLAB/johannesgerer-jburkardt-m/jburkardt-m-1726deb4a34dd08a49c26359d44ef47253f006c1/distmesh_3d/fd04.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8577681122619883, "lm_q2_score": 0.6992544335934766, "lm_q1q2_score": 0.5997981554943023}} {"text": "function cfactor = SC_AmplitudeFactor(blk, page, edgewt, sccalib)\n% Amplitude Factor: ce_i with Edge Response Function (edgewt)\n% Reference: Improved scatter correction using adaptive scatter kernel superposition\n% Author: Yi Du (yi.du@hotmail.com)\n% Date: 2021-05-24\n\n%% group number\nngroup = length(sccalib.CalibrationResults.ObjectScatterModels.ObjectScatterModel);\n\n% Amplitude factor groups\ncfactor = [];\n\nfor ii=1:ngroup\n tmp = sccalib.CalibrationResults.ObjectScatterModels.ObjectScatterModel{ii}.ObjectScatterFit;\n % Amplitude Factor\n % unit: mm - > cm\n A = str2double(tmp.A.Text) / 10;\n % unitless\n alpha = str2double(tmp.alpha.Text);\n beta = str2double(tmp.beta.Text);\n\n % fill holes\n term = (page + eps)./(blk + eps);\n logterm = -log(term);\n logterm(logterm<0) = NaN;\n logterm = single(inpaint_nans(double(logterm), 2));\n \n % amplitude factor wi edge response function as well\n cfactor(:,:,ii) = A .*edgewt .* (term).^(alpha) .* ( logterm ).^(beta); \nend\n\nend\n\n", "meta": {"author": "CERN", "repo": "TIGRE", "sha": "8df632662228d1b1c52afd95c90d0f7a9f8dc4b3", "save_path": "github-repos/MATLAB/CERN-TIGRE", "path": "github-repos/MATLAB/CERN-TIGRE/TIGRE-8df632662228d1b1c52afd95c90d0f7a9f8dc4b3/MATLAB/Utilities/IO/VarianCBCT/SC_AmplitudeFactor.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8577680977182186, "lm_q2_score": 0.6992544210587586, "lm_q1q2_score": 0.5997981345726255}} {"text": "%PARZENML Optimum smoothing parameter in Parzen density estimation.\n% \n% H = PARZENML(A)\n% \n% INPUT\t\n% A Input dataset\n%\n% OUTPUT\n% H Scalar smoothing parameter (in case of crisp labels)\n% Vector with smoothing parameters (in case of soft labels)\n%\n% DESCRIPTION\n% Maximum likelihood estimation for the smoothing parameter H in the \n% Parzen denstity estimation of the data in A. A leave-one out \n% maximum likelihood estimation is used. \n%\n% The dataset A can either be crisp or soft labeled. In case of crisp\n% labeling the class information is not used and a single smoothing \n% parameter is estimated. In case of soft labels a smoothing parameter\n% for every class is estimated and objects are weighted in relation to\n% their class weigthts (soft label value). \n% It may be profitable to scale the data before calling it. eg. \n% WS = SCALEM(A,'variance'); A = A*WS.\n% \n% SEE ALSO (PRTools Guide)\n% DATASETS, MAPPINGS, SCALEM, SELDAT, PARZENM, PARZENDC, PRPROGRESS\n\n% Copyright: R.P.W. Duin, r.p.w.duin@37steps.com\n% Faculty EWI, Delft University of Technology\n% P.O. Box 5031, 2600 GA Delft, The Netherlands\n\n% $Id: parzenml.m,v 1.11 2010/03/25 15:39:46 duin Exp $\n\nfunction h = parzenml(A,fid)\n\n\t\t\n\tif nargin < 2, fid = []; end\n\n\tif isdouble(A), A = prdataset(A); end\n\t\n\tA = testdatasize(A);\n\tA = testdatasize(A,'objects');\n\n\tif islabtype(A,'crisp')\n\t\th = parzenmlc(A,fid);\n\telseif islabtype(A,'soft')\n\t\th = parzenmls(A,fid);\n\telse\n\t\terror('Label type should be either ''crisp'' or ''soft''')\n\tend\n\t\n\treturn\n\t\nfunction h = parzenmlc(A,fid) %crisp version\n\n\t[m,k] = size(A);\n\tDD= distm(+A) + diag(1e70*ones(1,m));\n\tE = min(DD);\n\t\n\th1 = sqrt(max(E)); % initial estimate of h\n\tF1 = derlc(DD,E,h1,k); % derivative\n\n\tprprogress(fid,'parzenml:\\n');\n\tprprogress(fid,' %6.4f %6.3e\\n',h1,F1);\n\tif abs(F1) < 1e-70 \n\t\th = h1;\n\t\tprwarning(4,'jump out\\n');\n\t\treturn;\n\tend\n\t\n\ta1 = (F1+m*k)*h1*h1;\n\th2 = sqrt(a1/(m*k)); % second guess\n\tF2 = derlc(DD,E,h2,k); % derivative\n\n\tprprogress(fid,' %6.4f %6.3e\\n',h2,F2);\n\tif (abs(F2) < 1e-70) | (abs(1e0-h1/h2) < 1e-6) \n\t\th = h2;\n\t\tprwarning(4,'jump out\\n');\n\t\treturn\n\tend\n\t\n\t% find zero-point of derivative to optimize h^2\n\t% stop if improvement is small, or h does not change significantly\n\t\n\talf = 1;\n\tprwaitbar(100,'parzenml: Optimizing smoothing parameter',m > 100)\n\titer = 0;\n\twhile abs(1e0-F2/F1) > 1e-4 & abs(1e0-h2/h1) > 1e-3 & abs(F2) > 1e-70\n\t\titer = iter+1;\n\t\th3 = (h1*h1*h2*h2)*(F2-F1)/(F2*h2*h2-F1*h1*h1);\n\t\tif h3 < 0 % this should not happen\n\t\t\th3 = sqrt((F2+m*k)*h2*h2/(m*k));\n\t\telse\n\t\t\th3 = sqrt(h3);\n\t\tend\n\t\tprwaitbar(100,100-100*exp(-iter/10));\n\t\th3 = h2 +alf*(h3-h2);\n\t\tF3 = derlc(DD,E,h3,k);\n\t\tprprogress(fid,' %6.4f %6.3e\\n',h3,F3);\n\t\tF1 = F2; F2 = F3;\n\t\th1 = h2; h2 = h3;\n\t\talf = alf*0.99; % decrease step size\n\tend\n\th = h2;\n\tprwaitbar(0);\n\nreturn\n\nfunction F = derlc(DD,E,h,k) % crisp version\n\t% computation of the likelihood derivative for Parzen density\n\t% given distances D and their object minima E (for increased accuracy)\n\tm = size(DD,1);\n\twarning off MATLAB:divideByZero;\n\t\tY = (DD-repmat(E,m,1))/(2*h*h); % correct for minimum distance to save accuracy\n\twarning on MATLAB:divideByZero;\n\tIY = find(Y<20); % take small distance only, others don't contribute\n\tP = zeros(m,m);\n\tP(IY) = exp(-Y(IY));\n\tPP = sum(P,2)';\n\tFU = repmat(realmax,1,m);\n\tJ = find(PP~=0); \n\tFU(J) = 1./PP(J);\n\tFF = sum(DD.*P,2);\n\twarning off MATLAB:divideByZero;\n\t\tF = (FU*FF)./(h*h) - m*k;\n\twarning on MATLAB:divideByZero;\nreturn\n\nfunction h = parzenmls(A,fid) %soft version\n\n\tSS = gettargets(setlabtype(A,'soft'));\n\t[m,k,c] = getsize(A);\n\tDD= distm(+A) + diag(1e70*ones(1,m));\n\tE = min(DD);\n\th = zeros(c,1);\n\th0 = sqrt(max(E)); % initial estimate of h\n\t\n\t\n\ts = sprintf('parzenml: runover classes');\n\tprwaitbar(c,s,m > 100);\n\titer = 0;\n\t\n\tfor j=1:c\n\t\tprwaitbar(c,j)\n\t\tS = SS(:,j);\n\t\th1 = h0;\n\t\tF1 = derls(DD,E,h1,k,S); % derivative\n\n\t prprogress(fid,'parzenml: class %i : \\n',j);\n\t\tprprogress(fid,' %6.4f %6.3e\\n',h1,F1);\n\t\tif abs(F1) < 1e-70 \n\t\t\th(j) = h1;\n\t\t\tprwarning(4,'jump out\\n');\n\t\t\tbreak;\n\t\tend\n\t\n\t\ta1 = (F1+m*k)*h1*h1;\n\t\th2 = sqrt(a1/(m*k)); % second guess\n\t\tF2 = derls(DD,E,h2,k,S); % derivative\n\n\t\tprprogress(fid,' %6.4f %6.3e\\n',h2,F2);\n\t\tif (abs(F2) < 1e-70) | (abs(1e0-h1/h2) < 1e-6) \n\t\t\th(j) = h2;\n\t\t\tprwarning(4,'jump out\\n');\n\t\t\tbreak;\n\t\tend\n\t\n\t\t% find zero-point of derivative to optimize h^2\n\t\t% stop if improvement is small, or h does not change significantly\n\t\n\t\t\n\t\tprwaitbar(100,'parzenml: Optimizing smoothing parameter',m > 100)\n\t\titer = 0;\n\t\talf = 1;\n\t\twhile abs(1e0-F2/F1) > 1e-4 & abs(1e0-h2/h1) > 1e-3 & abs(F2) > 1e-70\n\t\t\titer = iter+1;\n\t\t\tprwaitbar(100,100-100*exp(-iter/10));\n\t\t\th3 = (h1*h1*h2*h2)*(F2-F1)/(F2*h2*h2-F1*h1*h1);\n\t\t\tif h3 < 0 % this should not happen\n\t\t\t\th3 = sqrt((F2+m*k)*h2*h2/(m*k));\n\t\t\telse\n\t\t\t\th3 = sqrt(h3);\n\t\t\tend\n\t\t\th3 = h2 +alf*(h3-h2);\n\t\t\tF3 = derls(DD,E,h3,k,S);\n\t\t\tprprogress(fid,' %6.4f %6.3e\\n',h3,F3);\n\t\t\tF1 = F2; F2 = F3;\n\t\t\th1 = h2; h2 = h3;\n\t\t\talf = alf*0.99; % decrease step size\n\t\tend\n\t\tprwaitbar(0)\n\t\th(j) = h2;\n\tend\n prwaitbar(0)\nreturn\n\nfunction F = derls(DD,E,h,k,S) %soft version\n\t% computation of the likelihood derivative for Parzen density\n\t% given distances D and their object minima E (for increased accuracy)\n\t% S are the object weigths\n\tc = size(S,2); % number of classes\n\tm = size(DD,1);\n\tY = (DD-repmat(E,m,1))/(2*h*h); % correct for minimum distance to save accuracy\n\tIY = find(Y<20); % take small distance only, others don't contribute\n\tF = 0;\n\tfor j=1:c\n\t\tP = zeros(m,m);\n\t\tP(IY) = exp(-Y(IY));\n\t\tPP = S(:,j)'*P';\n\t\tFU = repmat(realmax,1,m);\n\t\tJ = find(PP~=0); \n\t\tFU(J) = S(J,j)'./PP(J);\n\t\tK = find(S(:,j)==0);\n\t\tFU(K) = zeros(1,length(K));\n\t\tFF = (DD.*P)*S(:,j);\n\t\tF = F + (FU*FF)./(h*h);\n\tend\n\tF = F - sum(S(:))*k;\nreturn\n", "meta": {"author": "marianux", "repo": "ecg-kit", "sha": "c8e3de47c54a9214138143676d2aa546b0540dd2", "save_path": "github-repos/MATLAB/marianux-ecg-kit", "path": "github-repos/MATLAB/marianux-ecg-kit/ecg-kit-c8e3de47c54a9214138143676d2aa546b0540dd2/common/prtools/parzenml.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8577681013541611, "lm_q2_score": 0.6992544147913994, "lm_q1q2_score": 0.5997981317391337}} {"text": "function [cc] = oz2cc(oz)\n% Convert volume from US liquid ounces to cubic centimeters. \n% Chad Greene 2012\ncc = oz*29.573529563;", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/35258-unit-converters/unit_converters/oz2cc.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8459424528443252, "lm_q2_score": 0.7090191460821871, "lm_q1q2_score": 0.5997893955503543}} {"text": "function [ Q, sumQ] = OffpolicyQlearning150816( qldata3 , gamma, alpha, numtraces)\n% OFF POLICY Q LEARNING\n\n%initialisation of variables\nsumQ=zeros(numtraces,1); %record sum of Q after each iteration\nnact=numel(unique(qldata3(:,3)))-1; %nr of actions\nncl=numel(unique(qldata3(:,2)));\nQ=zeros (ncl, nact); \nmaxavgQ=1;\nmodu=100;\nlisti=find(qldata3(:,1)==1); %position of 1st step of each episodes in dataset\nnrepi=numel(listi); %nr of episodes in the dataset\njj=1;\n\n for j=1:numtraces\n \n \n i=listi(floor(rand()*(nrepi-2))+1); %pick one episode randomly (not the last one!)\n trace = [];\n \n while qldata3(i+1,1)~=1 \n S1=qldata3(i+1,2);\n a1=qldata3(i+1,3);\n r1=qldata3(i+1,4);\n step = [ r1, S1, a1 ];\n trace = [trace ; step];\n i=i+1;\n end\n\n tracelength = length(trace(:,1));\n return_t = trace(tracelength,1); % get last reward as return for penultimate state and action.\n \n for t=tracelength-1:-1:1 %Step through time-steps in reverse order\n s = trace(t,2); % get state index from trace at time t\n a = trace(t,3); % get action index\n Q(s,a) = (1-alpha)*Q(s,a) + alpha*return_t; % update Q.\n return_t = return_t*gamma + trace(t,1); % return for time t-1 in terms of return and reward at t\n end\n \n sumQ(jj,1)=sum(sum(Q));\n jj=jj+1;\n \n if mod(j,500*modu)==0 %check if can stop iterating (when no more improvement is seen)\n% sumQ(jj,1)=sum(sum(Q));\n% jj=jj+1;\n s=mean(sumQ(j-49999:j));\n d=(s-maxavgQ)/maxavgQ;\n if abs(d)<0.001\n break %exit routine\n end\n maxavgQ=s;\n end\n \n\n end\n\n sumQ(jj:end)=[];\n \n \nend\n\n", "meta": {"author": "matthieukomorowski", "repo": "AI_Clinician", "sha": "0669f8907e65503641857ca76aa46938641e513f", "save_path": "github-repos/MATLAB/matthieukomorowski-AI_Clinician", "path": "github-repos/MATLAB/matthieukomorowski-AI_Clinician/AI_Clinician-0669f8907e65503641857ca76aa46938641e513f/OffpolicyQlearning150816.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424450764199, "lm_q2_score": 0.7090191460821871, "lm_q1q2_score": 0.5997893900427607}} {"text": "% VL_TEST_IMWBACKWARDMX Test: imwbackwardmx\n\nI = vl_test_pattern(102) ;\n\nfigure(1) ; clf ;\nimagesc(I) ;\ncolormap(gray(256)) ;\naxis equal ; axis off ;\n\n[M,N] = size(I) ;\nur = linspace(-N/2, N/2, N) ;\nvr = linspace(-M/2, M/2, M) ;\n[u,v] = meshgrid(ur,vr) ;\n\nfor s=.75*(1+cos(linspace(0,2*pi,100)))/2+.25\n up = (cos(s-1)*u - sin(s-1)*v) / s ;\n vp = (sin(s-1)*u + cos(s-1)*v) / s ;\n J = vl_imwbackward(ur,vr,vl_imsmooth(I,1/s*.5),up,vp) ;\n imagesc(J) ; drawnow ;\nend\n", "meta": {"author": "jianxiongxiao", "repo": "ProfXkit", "sha": "7376c50abf5ead846247774a36be026e6f24953c", "save_path": "github-repos/MATLAB/jianxiongxiao-ProfXkit", "path": "github-repos/MATLAB/jianxiongxiao-ProfXkit/ProfXkit-7376c50abf5ead846247774a36be026e6f24953c/SiftFu/SiftFu/SIFTransac/vlfeat/toolbox/test/vl_test_imwbackwardmx.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8459424528443251, "lm_q2_score": 0.7090191276365462, "lm_q1q2_score": 0.5997893799464035}} {"text": "function wcoef = FWT_PO(x,L,qmf)\n% FWT_PO -- Forward Wavelet Transform (periodized, orthogonal)\n% Usage\n% wc = FWT_PO(x,L,qmf)\n% Inputs\n% x 1-d signal; length(x) = 2^J\n% L Coarsest Level of V_0; L << J\n% qmf quadrature mirror filter (orthonormal)\n% Outputs\n% wc 1-d wavelet transform of x.\n%\n% Description\n% 1. qmf filter may be obtained from MakeONFilter \n% 2. usually, length(qmf) < 2^(L+1)\n% 3. To reconstruct use IWT_PO\n%\n% See Also\n% IWT_PO, MakeONFilter\n%\n [n,J] = dyadlength(x) ;\n wcoef = zeros(1,n) ;\n beta = ShapeAsRow(x); %take samples at finest scale as beta-coeffts\n for j=J-1:-1:L\n alfa = DownDyadHi(beta,qmf);\n wcoef(dyad(j)) = alfa;\n beta = DownDyadLo(beta,qmf) ; \n end\n wcoef(1:(2^L)) = beta;\n wcoef = ShapeLike(wcoef,x);\n\n%\n% Copyright (c) 1993. Iain M. Johnstone\n% \n \n \n\n \n \n \n%\n% Part of Wavelab Version 850\n% Built Tue Jan 3 13:20:40 EST 2006\n% This is Copyrighted Material\n% For Copying permissions see COPYING.m\n% Comments? e-mail wavelab@stat.stanford.edu \n", "meta": {"author": "BUNPC", "repo": "Homer3", "sha": "d0fac4b22d1069eaa5cba268a225eb117ddcdca1", "save_path": "github-repos/MATLAB/BUNPC-Homer3", "path": "github-repos/MATLAB/BUNPC-Homer3/Homer3-d0fac4b22d1069eaa5cba268a225eb117ddcdca1/FuncRegistry/UserFunctions/FWT_PO.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406087, "lm_q2_score": 0.7090191460821871, "lm_q1q2_score": 0.5997893790275731}} {"text": "function cond = condition_linpack ( n, a )\n\n%*****************************************************************************80\n%\n%% CONDITION_LINPACK estimates the L1 condition number of a matrix.\n%\n% Discussion:\n%\n% The R8GE storage format is used for a general M by N matrix. A storage \n% space is made for each logical entry. The two dimensional logical\n% array is mapped to a vector, in which storage is by columns.\n%\n% For the system A * X = B, relative perturbations in A and B\n% of size EPSILON may cause relative perturbations in X of size\n% EPSILON*RCOND.\n%\n% Licensing:\n%\n% This code is distributed under the GNU LGPL license.\n%\n% Modified:\n%\n% 21 March 2004\n%\n% Author:\n%\n% Original FORTRAN77 version by Dongarra, Bunch, Moler, Stewart.\n% MATLAB version by John Burkardt.\n%\n% Reference:\n%\n% Dongarra, Bunch, Moler, Stewart,\n% LINPACK User's Guide,\n% SIAM, 1979\n%\n% Parameters:\n%\n% Input, integer N, the order of the matrix A.\n%\n% Input, real A(N,N), a matrix to be factored.\n%\n% Output, real COND, an estimate of the condition number of A.\n%\n\n%\n% Compute the L1 norm of A.\n%\n anorm = norm ( a, 1 );\n%\n% Compute the LU factorization.\n%\n [ a_lu, pivot, info ] = r8ge_fa ( n, a );\n%\n% COND = norm(A) * (estimate of norm(inverse(A))) \n%\n% estimate of norm(inverse(A)) = norm(Z) / norm(Y)\n%\n% where\n% A * Z = Y\n% and\n% A' * Y = E\n%\n% The components of E are chosen to cause maximum local growth in the\n% elements of W, where U'*W = E. The vectors are frequently rescaled\n% to avoid overflow.\n%\n% Solve U' * W = E.\n%\n ek = 1.0;\n z(1:n,1) = 0.0;\n\n for k = 1 : n\n\n if ( z(k,1) ~= 0.0 )\n ek = - r8_sign ( z(k,1) ) * abs ( ek );\n end\n\n if ( abs ( a_lu(k,k) ) < abs ( ek - z(k,1) ) )\n s = abs ( a_lu(k,k) ) / abs ( ek - z(k,1) );\n z(1:n,1) = s * z(1:n,1);\n ek = s * ek;\n end\n\n wk = ek - z(k,1);\n wkm = -ek - z(k,1);\n s = abs ( wk );\n sm = abs ( wkm );\n\n if ( a_lu(k,k) ~= 0.0 )\n wk = wk / a_lu(k,k);\n wkm = wkm / a_lu(k,k);\n else\n wk = 1.0;\n wkm = 1.0;\n end\n\n if ( k + 1 <= n )\n\n for j = k + 1 : n\n sm = sm + abs ( z(j,1) + wkm * a_lu(k,j) );\n z(j,1) = z(j,1) + wk * a_lu(k,j);\n s = s + abs ( z(j,1) );\n end\n\n if ( s < sm )\n t = wkm - wk;\n wk = wkm;\n z(k+1:n,1) = z(k+1:n,1) + t * a_lu(k,k+1:n)';\n end\n\n end\n\n z(k,1) = wk;\n\n end\n\n t = sum ( abs ( z(1:n,1) ) );\n z(1:n,1) = z(1:n,1) / t;\n%\n% Solve L' * Y = W\n%\n for k = n : -1 : 1\n\n z(k,1) = z(k,1) + a_lu(k+1:n,k)' * z(k+1:n,1);\n\n t = abs ( z(k,1) );\n\n if ( 1.0 < t )\n z(1:n,1) = z(1:n,1) / t;\n end\n\n l = pivot(k);\n\n t = z(l,1);\n z(l,1) = z(k,1);\n z(k,1) = t;\n\n end\n\n z(1:n,1) = z(1:n,1) / sum ( abs ( z(1:n,1) ) );\n\n ynorm = 1.0;\n%\n% Solve L * V = Y.\n%\n for k = 1 : n\n\n l = pivot(k);\n\n t = z(l,1);\n z(l,1) = z(k,1);\n z(k,1) = t;\n\n z(k+1:n,1) = z(k+1:n,1) + t * a_lu(k+1:n,k);\n\n if ( 1.0 < abs ( z(k,1) ) )\n ynorm = ynorm / abs ( z(k,1) );\n z(1:n) = z(1:n) / abs ( z(k,1) );\n end\n\n end\n\n s = sum ( abs ( z(1:n,1) ) );\n z(1:n,1) = z(1:n,1) / s;\n ynorm = ynorm / s;\n%\n% Solve U * Z = V.\n%\n for k = n : -1 : 1\n\n if ( abs ( a_lu(k,k) ) < abs ( z(k,1) ) )\n s = abs ( a_lu(k,k) ) / abs ( z(k,1) );\n z(1:n,1) = s * z(1:n,1);\n ynorm = s * ynorm;\n end\n\n if ( a_lu(k,k) ~= 0.0 )\n z(k,1) = z(k,1) / a_lu(k,k);\n else\n z(k,1) = 1.0;\n end\n\n z(1:k-1,1) = z(1:k-1,1) - a_lu(1:k-1,k) * z(k,1);\n\n end\n%\n% Normalize Z in the L1 norm.\n%\n s = 1.0 / sum ( abs ( z(1:n,1) ) );\n z(1:n,1) = s * z(1:n,1);\n ynorm = s * ynorm;\n\n cond = anorm / ynorm;\n\n return\nend\n", "meta": {"author": "johannesgerer", "repo": "jburkardt-m", "sha": "1726deb4a34dd08a49c26359d44ef47253f006c1", "save_path": "github-repos/MATLAB/johannesgerer-jburkardt-m", "path": "github-repos/MATLAB/johannesgerer-jburkardt-m/jburkardt-m-1726deb4a34dd08a49c26359d44ef47253f006c1/condition/condition_linpack.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.7090191399336402, "lm_q1q2_score": 0.5997893738262565}} {"text": "%JSINGU Show the linearly dependent joints in a Jacobian matrix\n%\n% JSINGU(J) displays the linear dependency of joints in a Jacobian matrix.\n% This dependency indicates joint axes that are aligned and causes singularity.\n%\n% See also SerialLink.jacobn.\n\n\n% Copyright (C) 1993-2015, by Peter I. Corke\n%\n% This file is part of The Robotics Toolbox for MATLAB (RTB).\n% \n% RTB is free software: you can redistribute it and/or modify\n% it under the terms of the GNU Lesser General Public License as published by\n% the Free Software Foundation, either version 3 of the License, or\n% (at your option) any later version.\n% \n% RTB is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU Lesser General Public License for more details.\n% \n% You should have received a copy of the GNU Leser General Public License\n% along with RTB. If not, see .\n%\n% http://www.petercorke.com\n\nfunction jsingu(J)\n\n % convert to row-echelon form\n [R, jb] = rref(J);\n\n depcols = setdiff( 1:numcols(J), jb);\n\n fprintf('%d linearly dependent joints:\\n', length(depcols));\n for d=depcols\n fprintf(' q%d depends on: ', d)\n for k=find(R(:,d))\n fprintf('q%d ', k);\n end\n fprintf('\\n');\n end\n", "meta": {"author": "Allopart", "repo": "rbpf-gmapping", "sha": "affe0adc25fa446fc7af4902d699d92864bdba1b", "save_path": "github-repos/MATLAB/Allopart-rbpf-gmapping", "path": "github-repos/MATLAB/Allopart-rbpf-gmapping/rbpf-gmapping-affe0adc25fa446fc7af4902d699d92864bdba1b/rvctools/robot/jsingu.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.7090191337850932, "lm_q1q2_score": 0.5997893686249397}} {"text": "function pass = test_curl( pref ) \n\n% Grab some preferences\nif ( nargin == 0 )\n pref = chebfunpref();\nend\ntol = 1e2*pref.techPrefs.chebfuneps;\n\n% Example 1 : (0,x,xy)\nVx = ballfun(@(x,y,z)0);\nVy = ballfun(@(r,lam,th)r.*sin(th).*cos(lam), 'spherical');\nVz = ballfun(@(r,lam,th)r.*sin(th).*cos(lam).*r.*sin(th).*sin(lam), 'spherical');\nV = ballfunv(Vx,Vy,Vz);\nW = curl(V);\nExactx = ballfun(@(r,lam,th)r.*sin(th).*cos(lam), 'spherical');\nExacty = ballfun(@(r,lam,th)-r.*sin(th).*sin(lam), 'spherical');\nExactz = ballfun(@(r,lam,th)1, 'spherical');\nExact = ballfunv(Exactx,Exacty,Exactz);\npass(1) = norm(W-Exact) 0)\n pass = all(pass(:));\nend\nend", "meta": {"author": "chebfun", "repo": "chebfun", "sha": "8c49396a55e46ddd57a1d108c6a8f32e37536d54", "save_path": "github-repos/MATLAB/chebfun-chebfun", "path": "github-repos/MATLAB/chebfun-chebfun/chebfun-8c49396a55e46ddd57a1d108c6a8f32e37536d54/tests/ballfunv/test_curl.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.7090191276365462, "lm_q1q2_score": 0.5997893634236229}} {"text": "function [F,F_r,F_u] = odo3(F,u)\n\n% ODO3 3D Odometry evolution.\n% F = ODO3(F,U) performs one step on the pose F of a vehicle, given\n% odometry increments U=[DX;DV] in robot frame.\n% - F is a frame structure (see FRAME).\n% - Position increment DX is given in robot frame F.\n% - Orientation increment DV is given as a Rotation Vector in robot frame F.\n%\n% [F,F_r,F_u] = ODO3(F,U) gives the full Jacobians wrt state and odometry\n% inputs.\n%\n% See also FRAME, V2Q, QPROD, QUATERNION.\n\n% Copyright 2005-2009 Joan Sola @ LAAS-CNRS.\n\ndv = u(4:6);\ndx = u(1:3);\n\nif nargout == 1\n\n x = fromFrame(F,dx); % Position update\n\n q = F.x(4:end);\n q2 = qProd(q,v2q(dv)); % quaternion update\n\n F.x = [x;q2]; % frame update\n\n\nelse % Jacobians\n\n [x,X_r,X_dx] = fromFrame(F,dx); % Position update and jacobians\n\n q = F.x(4:end);\n [dq,DQ_dv] = v2q(dv);\n [q2,Q2_q,Q2_dq] = qProd(q,dq); % quaternion update\n Q2_dv = Q2_dq*DQ_dv;\n\n F.x = [x;q2]; % frame update\n\n F_r = [X_r;zeros(4,3) Q2_q];\n F_u = [X_dx zeros(3,3);zeros(4,3) Q2_dv];\nend\n\nF = updateFrame(F);\n\nreturn\n\n%% Jacobians\n\nsyms x y z a b c d real\nsyms dx dy dz dp dq dr real\nFi.x=[x;y;z;a;b;c;d];\nDx = [dx;dy;dz];\nDv = [dp;dq;dr];\nu = [Dx;Dv];\n\nFi = updateFrame(Fi);\n\n[F,F_r,F_u] = odo3(Fi,u);\n\nF_rs = jacobian(F.x,Fi.x);\nF_us = jacobian(F.x,[Dx;Dv]);\n\nsimplify(F_r-F_rs)\nsimplify(F_u-F_us)\n\n\n\n% ========== End of function - Start GPL license ==========\n\n\n% # START GPL LICENSE\n\n%---------------------------------------------------------------------\n%\n% This file is part of SLAMTB, a SLAM toolbox for Matlab.\n%\n% SLAMTB is free software: you can redistribute it and/or modify\n% it under the terms of the GNU General Public License as published by\n% the Free Software Foundation, either version 3 of the License, or\n% (at your option) any later version.\n%\n% SLAMTB is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU General Public License for more details.\n%\n% You should have received a copy of the GNU General Public License\n% along with SLAMTB. If not, see .\n%\n%---------------------------------------------------------------------\n\n% SLAMTB is Copyright:\n% Copyright (c) 2008-2010, Joan Sola @ LAAS-CNRS,\n% Copyright (c) 2010-2013, Joan Sola,\n% Copyright (c) 2014-2015, Joan Sola @ IRI-UPC-CSIC,\n% SLAMTB is Copyright 2009 \n% by Joan Sola, Teresa Vidal-Calleja, David Marquez and Jean Marie Codol\n% @ LAAS-CNRS.\n% See on top of this file for its particular copyright.\n\n% # END GPL LICENSE\n\n", "meta": {"author": "joansola", "repo": "slamtb", "sha": "b4767f6bf38bceed205abb85f1aed12422c9a972", "save_path": "github-repos/MATLAB/joansola-slamtb", "path": "github-repos/MATLAB/joansola-slamtb/slamtb-b4767f6bf38bceed205abb85f1aed12422c9a972/Kinematics/odo3.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424295406088, "lm_q2_score": 0.7090191276365462, "lm_q1q2_score": 0.5997893634236229}} {"text": "function pde = hyperIntf(am,ap,bm,bp,r,x0,y0,z0)\n%% USAGE: polynomial solution for Poisson equation\n% Last Modified: 02/21/2020 by Xu Zhang\n\n%% PDE Structure\npde = struct('intf',@intf,...\n 'exactu1',@exactu1,'exactu2',@exactu2,'exactu3',@exactu3,...\n 'um1',@um1,'um2',@um2,'um3',@um3,'up1',@up1,'up2',@up2,'up3',@up3,...\n 'Dxu',@Dxu,'Dxum',@Dxum,'Dxup',@Dxup,'Dyu',@Dyu,...\n 'Dyum',@Dyum,'Dyup',@Dyup,'Dzu',@Dzu,'Dzum',@Dzum,'Dzup',@Dzup,...\n 'f1',@f1,'f2',@f2,'f3',@f3,...\n 'fm1',@fm1,'fm2',@fm2,'fm3',@fm3,...\n 'fp1',@fp1,'fp2',@fp2,'fp3',@fp3,...\n 'A',@A,'Am',@Am,'Ap',@Ap,'one',@one,...\n 'B',@B,'Bm',@Bm,'Bp',@Bp);\n\npde.am = am;\npde.ap = ap;\npde.bm = bm;\npde.bp = bp;\n%% interface function\n function u = intf(x,y,z)\n u = ((x-x0).^2 + (y-y0).^2 - (z-z0).^2)-r;\n end\n\n%% exact solution\n function u = exactu1(x,y,z)\n u = um1(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = up1(x(id),y(id),z(id));\n end\n function u = exactu2(x,y,z)\n u = um2(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = up2(x(id),y(id),z(id));\n end\n function u = exactu3(x,y,z)\n u = um3(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = up3(x(id),y(id),z(id));\n end\n coef1 = 1; coef2 = 0; coef3 = 1;\n function u = um1(x,y,z)\n u = coef1*(z-z0) + coef3*(x-x0)/bm + coef2*intf(x,y,z).*(x-x0)/am;\n end\n function u = um2(x,y,z)\n u = coef3*(y-y0)/bm + coef2*intf(x,y,z).*(y-y0)/am;\n end\n function u = um3(x,y,z)\n u = coef1*(x-x0) - coef3*(z-z0)/bm + coef2*intf(x,y,z).*(z-z0)/am;\n end\n function u = up1(x,y,z)\n u = coef1*(z-z0) + coef3*(x-x0)/bp + coef2*intf(x,y,z).*(x-x0)/ap;\n end\n function u = up2(x,y,z)\n u = coef3*(y-y0)/bp + coef2*intf(x,y,z).*(y-y0)/ap;\n end\n function u = up3(x,y,z)\n u = coef1*(x-x0) - coef3*(z-z0)/bp + coef2*intf(x,y,z).*(z-z0)/ap;\n end\n%% Boundary Function\n function u = gD1(x,y,z)\n u = exactu1(x,y,z);\n end\n function u = gD2(x,y,z)\n u = exactu2(x,y,z);\n end\n function u = gD3(x,y,z)\n u = exactu3(x,y,z);\n end\n%% Derivative of the exact solution\n function u = Dxu(x,y,z)\n u = Dxum(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = Dxup(x(id),y(id),z(id));\n end\n function u = Dyu(x,y,z)\n u = Dyum(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = Dyup(x(id),y(id),z(id));\n end\n function u = Dzu(x,y,z)\n u = Dzum(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = Dzup(x(id),y(id),z(id));\n end\n function u = Dxum(x,y,z)\n u = 4*(y-y0).*(z-z0)/am*coef2;\n end\n function u = Dyum(x,y,z)\n u = -4*(x-x0).*(z-z0)/am*coef2;\n end\n function u = Dzum(x,y,z)\n u = zeros(size(x));\n end\n function u = Dxup(x,y,z)\n u = 4*(y-y0).*(z-z0)/ap*coef2;\n end\n function u = Dyup(x,y,z)\n u = -4*(x-x0).*(z-z0)/ap*coef2;\n end\n function u = Dzup(x,y,z)\n u = zeros(size(x));\n end\n\n%% right hand side function\n function u = f1(x,y,z)\n u = fm1(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = fp1(x(id),y(id),z(id));\n end\n function u = f2(x,y,z)\n u = fm2(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = fp2(x(id),y(id),z(id));\n end\n function u = f3(x,y,z)\n u = fm3(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = fp3(x(id),y(id),z(id));\n end\n\n function u = fm1(x,y,z)\n u = 4*(x-x0)*coef2 + bm*um1(x,y,z);\n end\n function u = fm2(x,y,z)\n u = 4*(y-y0)*coef2 + bm*um2(x,y,z);\n end\n function u = fm3(x,y,z)\n u = -8*(z-z0)*coef2 + bm*um3(x,y,z);\n end\n function u = fp1(x,y,z)\n u = 4*(x-x0)*coef2 + bp*up1(x,y,z);\n end\n function u = fp2(x,y,z)\n u = 4*(y-y0)*coef2 + bp*up2(x,y,z);\n end\n function u = fp3(x,y,z)\n u = -8*(z-z0)*coef2 + bp*up3(x,y,z);\n end\n\n%% Diffusion coefficient function\n function u = A(x,y,z)\n u = Am(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = Ap(x(id),y(id),z(id));\n end\n function u = Am(x,y,z)\n u = am*ones(size(x));\n end\n function u = Ap(x,y,z)\n u = ap*ones(size(x));\n end\n\n%% Mass coefficient function\n function u = B(x,y,z)\n u = Bm(x,y,z);\n id = intf(x,y,z) > 0;\n u(id) = Bp(x(id),y(id),z(id));\n end\n function u = Bm(x,y,z)\n u = bm*ones(size(x));\n end\n function u = Bp(x,y,z)\n u = bp*ones(size(x));\n end\n\n%% Other function\n function u = one(x,y,z)\n u = ones(size(x));\n end\nend", "meta": {"author": "lyc102", "repo": "ifem", "sha": "29f31c812001ca8d93dad08e67208ca60e8716d4", "save_path": "github-repos/MATLAB/lyc102-ifem", "path": "github-repos/MATLAB/lyc102-ifem/ifem-29f31c812001ca8d93dad08e67208ca60e8716d4/research/IVEM/hyperIntf.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8459424256566558, "lm_q2_score": 0.7090191276365462, "lm_q1q2_score": 0.5997893606698259}} {"text": "function loops=extractloops(edges)\n%\n% loops=extractloops(edges)\n%\n% extract individual loop or polyline segment from a collection of edges\n%\n% author: Qianqian Fang, \n% date: 2007/11/21\n%\n% input: \n% edges: two column matrix recording the starting/ending \n% points of all edge segments\n%\n% output:\n% loops: output, a single vector separated by NaN, each segment\n% is a 3D polyline or loop consisted of node IDs\n%\n% example:\n% edges=[1 2;2 3;1 4;3 4;7 3;1 9;5 6;6 7;10 9; 8 10;1 8;9 3;11 11;11 12];\n% loops=extractloops(edges)\n%\n% -- this function is part of iso2mesh toolbox (http://iso2mesh.sf.net)\n%\n\nloops=[];\nedges(edges(:,1)==edges(:,2),:)=[]; % remove degenerated edges\nloops=[loops,edges(1,:)];\nloophead=edges(1,1);\nloopend=edges(1,end);\nedges(1,:)=[];\n\nwhile(~isempty(edges))\n idx=[find(edges(:,1)==loopend)',find(edges(:,2)==loopend)'];\n if(length(idx)>1) % when a node with multiple connection found\n idx=idx(1); % take the first connection and continue\n end\n if(isempty(idx)) % when an open-line segment gets to one end\n % when both open ends are found\n if(isempty([find(edges(:,1)==loophead)',find(edges(:,2)==loophead)']))\n loops=[loops,nan];\n loops=[loops,edges(1,:)];\n loophead=edges(1,1);\n loopend=edges(1,end);\n edges(1,:)=[];\n else % only the first open end is found, flip and trace the other\n [loophead, loopend]=deal(loopend, loophead);\n lp=fliplr(loops);\n seg=find(isnan(lp),1);\n if(isempty(seg))\n loops=lp;\n else\n loops=[loops(1:end-seg(1)+1) lp(1:seg(1)-1)];\n end\n end\n continue; \n end\n if(length(idx)==1) % tracing along a single line thread\n idx=idx(1);\n ed=edges(idx,:);\n ed(ed==loopend)=[];\n newend=ed(1);\n if(newend==loophead) % when a loop is found\n loops=[loops loophead nan];\n edges(idx,:)=[];\n if(size(edges,1)==0) break; end\n loops=[loops,edges(1,:)];\n loophead=edges(1,1);\n loopend=edges(1,end);\n edges(1,:)=[];\n continue;\n else\n loops=[loops,newend];\n end\n loopend=newend;\n edges(idx,:)=[];\n end\nend\n \n", "meta": {"author": "fangq", "repo": "iso2mesh", "sha": "556f4c321467a3ee042d4c559b4edc11e01dc574", "save_path": "github-repos/MATLAB/fangq-iso2mesh", "path": "github-repos/MATLAB/fangq-iso2mesh/iso2mesh-556f4c321467a3ee042d4c559b4edc11e01dc574/extractloops.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7490872131147275, "lm_q2_score": 0.8006919997179627, "lm_q1q2_score": 0.5997881386319869}} {"text": "function a_inverse = r8ge_inverse ( n, a_lu, pivot )\n\n%*****************************************************************************80\n%\n%% R8GE_INVERSE computes the inverse of a matrix factored by R8GE_FA.\n%\n% Discussion:\n%\n% The R8GE storage format is used for a general M by N matrix. A storage \n% space is made for each logical entry. The two dimensional logical\n% array is mapped to a vector, in which storage is by columns.\n%\n% R8GE_INVERSE is a simplified standalone version of the LINPACK routine\n% R8GEDI.\n%\n% Licensing:\n%\n% This code is distributed under the GNU LGPL license.\n%\n% Modified:\n%\n% 20 March 2004\n%\n% Author:\n%\n% John Burkardt\n%\n% Parameters:\n%\n% Input, integer N, the order of the matrix A.\n%\n% Input, real A_LU(N,N), the factor information computed by R8GE_FA.\n%\n% Input, integer PIVOT(N), the pivot vector from R8GE_FA.\n%\n% Output, real A_INVERSE(N,N), the inverse matrix.\n%\n a_inverse(1:n,1:n) = a_lu(1:n,1:n);\n%\n% Compute Inverse(U).\n%\n for k = 1 : n\n\n a_inverse(k,k) = 1.0E+00 / a_inverse(k,k);\n a_inverse(1:k-1,k) = -a_inverse(1:k-1,k) * a_inverse(k,k);\n\n for j = k + 1 : n\n\n temp = a_inverse(k,j);\n a_inverse(k,j) = 0.0E+00;\n a_inverse(1:k,j) = a_inverse(1:k,j) + a_inverse(1:k,k) * temp;\n\n end\n\n end\n%\n% Form Inverse(U) * Inverse(L).\n%\n for k = n - 1 : -1 : 1\n\n work(k+1:n) = a_inverse(k+1:n,k);\n a_inverse(k+1:n,k) = 0.0E+00;\n\n for j = k + 1 : n\n a_inverse(1:n,k) = a_inverse(1:n,k) + a_inverse(1:n,j) * work(j);\n end\n\n if ( pivot(k) ~= k )\n\n for i = 1 : n\n t = a_inverse(i,k);\n a_inverse(i,k) = a_inverse(i,pivot(k));\n a_inverse(i,pivot(k)) = t;\n end\n\n end\n\n end\n\n return\nend\n", "meta": {"author": "johannesgerer", "repo": "jburkardt-m", "sha": "1726deb4a34dd08a49c26359d44ef47253f006c1", "save_path": "github-repos/MATLAB/johannesgerer-jburkardt-m", "path": "github-repos/MATLAB/johannesgerer-jburkardt-m/jburkardt-m-1726deb4a34dd08a49c26359d44ef47253f006c1/linplus/r8ge_inverse.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8006920020959545, "lm_q2_score": 0.7490872075132153, "lm_q1q2_score": 0.5997881359282241}} {"text": "function sphere_cubed_grid_points_display ( ns, xyz, filename )\n\n%*****************************************************************************80\n%\n%% SPHERE_CUBED_GRID_POINTS_DISPLAY displays the points on a cubed sphere grid.\n%\n% Licensing:\n%\n% This code is distributed under the GNU LGPL license.\n%\n% Modified:\n%\n% 09 May 2015\n%\n% Author:\n%\n% John Burkardt\n%\n% Parameters:\n%\n% Input, integer NS, the number of points.\n%\n% Output, real XYZ(NS,3), distinct points on the unit sphere\n% generated by a cubed sphere grid.\n%\n figure ( )\n clf\n hold on\n [ x, y, z ] = sphere ( 20 );\n c = ones ( size ( z ) );\n surf ( x, y, z, c );\n plot3 ( xyz(:,1), xyz(:,2), xyz(:,3), 'b.', 'Markersize', 20 );\n axis equal\n grid on\n view ( 3 )\n xlabel ( '<--X-->' )\n ylabel ( '<--Y-->' )\n zlabel ( '<--Z-->' )\n title_string = s_escape_tex ( filename )\n title ( title_string, 'FontSize', 24 );\n hold off\n\n print ( '-dpng', filename );\n fprintf ( 1, '\\n' );\n fprintf ( 1, ' Plot file saved to \"%s\".\\n', filename );\n\n return\nend\n", "meta": {"author": "johannesgerer", "repo": "jburkardt-m", "sha": "1726deb4a34dd08a49c26359d44ef47253f006c1", "save_path": "github-repos/MATLAB/johannesgerer-jburkardt-m", "path": "github-repos/MATLAB/johannesgerer-jburkardt-m/jburkardt-m-1726deb4a34dd08a49c26359d44ef47253f006c1/sphere_cubed_grid/sphere_cubed_grid_points_display.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7662936430859597, "lm_q2_score": 0.7826624840223698, "lm_q1q2_score": 0.5997492861882086}} {"text": "%% Machine Learning Online Class\n% Exercise 6 | Support Vector Machines\n%\n% Instructions\n% ------------\n% \n% This file contains code that helps you get started on the\n% exercise. You will need to complete the following functions:\n%\n% gaussianKernel.m\n% dataset3Params.m\n% processEmail.m\n% emailFeatures.m\n%\n% For this exercise, you will not need to change any code in this file,\n% or any other files other than those mentioned above.\n%\n\n%% Initialization\nclear ; close all; clc\n\n%% =============== Part 1: Loading and Visualizing Data ================\n% We start the exercise by first loading and visualizing the dataset. \n% The following code will load the dataset into your environment and plot\n% the data.\n%\n\nfprintf('Loading and Visualizing Data ...\\n')\n\n% Load from ex6data1: \n% You will have X, y in your environment\nload('ex6data1.mat');\n\n% Plot training data\nplotData(X, y);\n\nfprintf('Program paused. Press enter to continue.\\n');\n%pause;\n\n%% ==================== Part 2: Training Linear SVM ====================\n% The following code will train a linear SVM on the dataset and plot the\n% decision boundary learned.\n%\n\n% Load from ex6data1: \n% You will have X, y in your environment\nload('ex6data1.mat');\n\nfprintf('\\nTraining Linear SVM ...\\n')\n\n% You should try to change the C value below and see how the decision\n% boundary varies (e.g., try C = 1000)\nC = 100;\nmodel = svmTrain(X, y, C, @linearKernel, 1e-3, 20);\nvisualizeBoundaryLinear(X, y, model);\n\nfprintf('Program paused. Press enter to continue.\\n');\n%pause;\n\n%% =============== Part 3: Implementing Gaussian Kernel ===============\n% You will now implement the Gaussian kernel to use\n% with the SVM. You should complete the code in gaussianKernel.m\n%\nfprintf('\\nEvaluating the Gaussian Kernel ...\\n')\n\nx1 = [1 2 1]; x2 = [0 4 -1]; sigma = 2;\nsim = gaussianKernel(x1, x2, sigma);\n\nfprintf(['Gaussian Kernel between x1 = [1; 2; 1], x2 = [0; 4; -1], sigma = 0.5 :' ...\n '\\n\\t%f\\n(this value should be about 0.324652)\\n'], sim);\n\nfprintf('Program paused. Press enter to continue.\\n');\n%pause;\n\n%% =============== Part 4: Visualizing Dataset 2 ================\n% The following code will load the next dataset into your environment and \n% plot the data. \n%\n\nfprintf('Loading and Visualizing Data ...\\n')\n\n% Load from ex6data2: \n% You will have X, y in your environment\nload('ex6data2.mat');\n\n% Plot training data\nplotData(X, y);\n\nfprintf('Program paused. Press enter to continue.\\n');\n%pause;\n\n%% ========== Part 5: Training SVM with RBF Kernel (Dataset 2) ==========\n% After you have implemented the kernel, we can now use it to train the \n% SVM classifier.\n% \nfprintf('\\nTraining SVM with RBF Kernel (this may take 1 to 2 minutes) ...\\n');\n\n% Load from ex6data2: \n% You will have X, y in your environment\nload('ex6data2.mat');\n\n% SVM Parameters\nC = 1; sigma = 0.1;\n\n% We set the tolerance and max_passes lower here so that the code will run\n% faster. However, in practice, you will want to run the training to\n% convergence.\nmodel= svmTrain(X, y, C, @(x1, x2) gaussianKernel(x1, x2, sigma)); \nvisualizeBoundary(X, y, model);\n\nfprintf('Program paused. Press enter to continue.\\n');\n%pause;\n\n%% =============== Part 6: Visualizing Dataset 3 ================\n% The following code will load the next dataset into your environment and \n% plot the data. \n%\n\nfprintf('Loading and Visualizing Data ...\\n')\n\n% Load from ex6data3: \n% You will have X, y in your environment\nload('ex6data3.mat');\n\n% Plot training data\nplotData(X, y);\n\nfprintf('Program paused. Press enter to continue.\\n');\n%pause;\n\n%% ========== Part 7: Training SVM with RBF Kernel (Dataset 3) ==========\n\n% This is a different dataset that you can use to experiment with. Try\n% different values of C and sigma here.\n% \n\n% Load from ex6data3: \n% You will have X, y in your environment\nload('ex6data3.mat');\n\n% Try different SVM Parameters here\n[C, sigma] = dataset3Params(X, y, Xval, yval);\n\n% Train the SVM\nmodel= svmTrain(X, y, C, @(x1, x2) gaussianKernel(x1, x2, sigma));\nvisualizeBoundary(X, y, model);\n\nfprintf('Program paused. Press enter to continue.\\n');\npause;\n\n", "meta": {"author": "yhyap", "repo": "machine-learning-coursera", "sha": "fb33f0ad54ff2104660c86b0d26456b15029a798", "save_path": "github-repos/MATLAB/yhyap-machine-learning-coursera", "path": "github-repos/MATLAB/yhyap-machine-learning-coursera/machine-learning-coursera-fb33f0ad54ff2104660c86b0d26456b15029a798/mlclass-ex6/ex6.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.782662489091802, "lm_q2_score": 0.7662936377487305, "lm_q1q2_score": 0.599749285895633}} {"text": "function f = randarb(x,y)\n% RANDARB generates a random observation from any arbitrary PDF defined by x,y\n% function f = hfarbrand(x,y) x and y are vectors of length N that describe a PDF\n% to some precision implicitly dictated by the size of N. Fhe returned scalar f\n% is an observation from the set of x with a probability of (x/y(x))/sum(y)\n\n%% Sanity checks\nif nargin ~= 2\n error('Two input vectors are required');\nend\nif length(x) ~= length(y)\n error('x and y must be of the same length');\nend\nif length(x) < 30\n warning('The size of x and y is very low');\nend\n\n%% Compute a uniform random number between 0 and sum(y)\nrandx = sum(y)*rand();\n\n%% Find where the number lies on a conceptual line comprised of \"segments\" of\n% length y\ni = 1;\nwhile sum(y(1:i)) < randx\n i = i + 1;\nend\n\n%% Return the x value corresponding to the y value we \"landed on.\"\nf = x(i);", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/6506-obs-from-arbitrary-pdf/randarb.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.905989815306765, "lm_q2_score": 0.6619228825191872, "lm_q1q2_score": 0.5996953900808799}} {"text": "% MATLAB computation of pulse transformer model - DS Method\n% File: c:\\M_files\\shortcuts\\xfrmrds2.m\n% 9/19/02; 4/17/04; 2/15/07\n% \ntic;clc;clear;\nK=1e3;pF=1e-12;mH=1e-3;uH=1e-6;ns=1e-9;ps=1e-12; % unit suffixes\n%\n% Components\n%\nR1=10;R2=1.5;R3=20*K;R4=1.5;R5=1*K;R6=0.5;R7=1;\nC1=20*pF;C2=5*pF;C3=20*pF;L1=1*uH;L2=2*mH;L3=1*uH;\n%\n% Get A, B, D, & E arrays; this function called only once.\n%\nNom=[R1 R2 R3 R4 R5 R6 R7 C1 C2 C3 L1 L2 L3];\n[A,B,D,E,I]=tfrmr2(Nom);\n%\n% * * * * * * * * * * * * Frequency response * * * * * * * * * * * *\n%\nEin=10; % Change Ein from 1V to 10V.\n%\nBF=2;ND=6;PD=50;NP=ND*PD+1;L=linspace(BF,BF+ND,NP);\n%\n% Since the output is vC3, we dont need the D and E arrays. \n% The cv output below is [vC1 vC2 vC3 iL1 iL2 iL3]'\n% (a column vector). Hence we need vC3 or cv(3).\n%\nfor i=1:NP\n F=10^L(i);s=2*pi*F*j;\n cx=(s*I-A)\\B*Ein;\n% cy=D*cx+E*Ein; % cy not used \n Vo=abs(cx(3)); % vC3 = Vo\n Vf(i)=20*log10(Vo); \nend\n%\n% * * * * * * * * * * * * * Transient response * * * * * * * * * * * \n%\nTx=1/max(max(abs(A)));\ndisp('Shortest circuit time constant');Tx\n%Per=input('Sweep time? (sec)');\n% set Sweep time to 200ns = 200e-9 to match Spice run.\nPer=200*ns;\nkmax=1e5; % kmax increased due to fast time constant Tx\ndt = 2*ps\nN=6;\n%dt=Per/kmax;N=6;\nt1=linspace(0,Per,kmax);IV=zeros(N,kmax);\n%\n% input ramp parameters\n%\np=Ein/(5*dt);b=6*dt;pw=5e4*dt;c=pw+6*dt;d=pw+11*dt;\nEa1=ramp1(p,t1(1),dt)-ramp1(p,t1(1),b)-ramp1(p,t1(1),c)+ramp1(p,t1(1),d);\n% initialize k = 1\nIV(:,1)=B*Ea1*dt;\n%\n% iterate for k = 2,3,...kmax\n%\nfor k=2:kmax\n Eak=ramp1(p,t1(k),dt)-ramp1(p,t1(k),b)-ramp1(p,t1(k),c)+ramp1(p,t1(k),d);\n IV(:,k)=A*IV(:,k-1)*dt+B*Eak*dt+IV(:,k-1);\nend\n%\n% Plot frequency response\n%\nsubplot(2,1,1)\nh=plot(L,Vf,'k');\nset(h,'LineWidth',2);\ngrid on;\naxis([BF BF+ND -40 30]);\nXT=linspace(BF,BF+ND,7);\nset(gca,'xtick',XT);\nylabel('dBV');title('AC Output Vc3');\nxlabel('Log Freq(Hz)');\n%\n% Plot time response\n%\nsubplot(2,1,2)\nh=plot(t1/ns,IV(1,:),'k',t1/ns,IV(3,:),'r');\nset(h,'LineWidth',2);\naxis auto\ngrid on;ylabel('Volts');title('Transient response, Vc1 & Vc3');\nxlabel('nsec');\nlegend('Vc1','Vc3');\n\nfigure(1) % display plot on screen.\n%\ndisp(' ');disp('Execution time in seconds');\nET=toc\n \n\n\n\n\n\n", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/2435-shortcut-state-space-circuit-analysis/Matlab_Files/xfrmrds2.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9059898178450964, "lm_q2_score": 0.6619228758499942, "lm_q1q2_score": 0.5996953857188386}} {"text": "function f = smiley(varargin)\n\nif nargin == 0 || ~isa(varargin{1},'vector3d')\n if check_option(varargin,'exact')\n f = S2FunHandle(@(v) S2Fun.smiley(v));\n else\n f = S2FunHarmonic.quadrature(@(v) S2Fun.smiley(v),varargin{:});\n end\n return;\nend\n\nv = varargin{1};\nv = v(:)';\n\n% Radial test function: quadratic spline\nf_r = @(z,h) (z>h).*(z-h).^2./(1-h).^2;\nif check_option(varargin,'even')\n f_r = @(z,h) f_r(z,h)+f_r(-z,h); % f has to be even\nend\n\nx_0 = [pi/2,0; 0.6,-0.6; 0.6,0.6; -0.5,-1; -0.5,-0.5; -0.5,0; -0.5,0.5; -0.5,1];\nh_0 = [0.7; 0.96; 0.96; 0.93; 0.93; 0.93; 0.93; 0.93];\nc_0 = [0.5; -0.5; -0.5; 0.25; 0.25; 0.25; 0.25; 0.25];\n\ncenters = vector3d.byPolar(x_0(:, 1), x_0(:, 2));\nif strcmpi(getMTEXpref('xAxisDirection'),'east')\n centers = rotate(centers,90*degree);\nend\n\n% TODO: upper line can be replaced by lower line with Matlab 2017\nfh = @(v) (sum(repmat(c_0,1,length(v)) .* f_r(dot(repmat(v,length(centers),1), repmat(centers,1,length(v))), repmat(h_0,1,length(v))), 1))';\n%fh = @(v) (sum(c_0.*f_r(dot(v, centers), h_0), 1))';\n\nf = fh(v);\n\nend\n", "meta": {"author": "mtex-toolbox", "repo": "mtex", "sha": "f0ce46a720935e9ae8106ef919340534bca1adcb", "save_path": "github-repos/MATLAB/mtex-toolbox-mtex", "path": "github-repos/MATLAB/mtex-toolbox-mtex/mtex-f0ce46a720935e9ae8106ef919340534bca1adcb/S2Fun/@S2Fun/smiley.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382236515258, "lm_q2_score": 0.6959583376458152, "lm_q1q2_score": 0.5995947099508444}} {"text": "function [W] = spm_Volt_W(u)\n% returns basis functions used for Volterra expansion\n% FORMAT [W] = spm_Volt_W(u);\n% u - times {seconds}\n% W - basis functions (mixture of Gammas)\n%_______________________________________________________________________\n% Copyright (C) 2008 Wellcome Trust Centre for Neuroimaging\n\n% Karl Friston\n% $Id: spm_Volt_W.m 1143 2008-02-07 19:33:33Z spm $\n\n\nu = u(:);\nW = [];\nfor i = 2:4\n m = (2^i);\n s = sqrt(m);\n W = [W spm_Gpdf(u,(m/s)^2,m/s^2)];\nend\n", "meta": {"author": "spm", "repo": "spm12", "sha": "3085dac00ac804adb190a7e82c6ef11866c8af02", "save_path": "github-repos/MATLAB/spm-spm12", "path": "github-repos/MATLAB/spm-spm12/spm12-3085dac00ac804adb190a7e82c6ef11866c8af02/spm_Volt_W.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8615382165412809, "lm_q2_score": 0.6959583376458153, "lm_q1q2_score": 0.5995947050024103}} {"text": "N = 24; % Prediction horizon (number of iterations)\nNu = N; % Control horizon (number of iterations) \nQ = [1 0 1 0 0]; % State weights\nR = 0; % du weights\nRu = 1; % u weights\nLB = 0*ones(Nu,1); % Lower bound of control input\nUB = 1*ones(Nu,1); % Upper bound of control input\nLBdu = nan; % Lower bound of control input rate\nUBdu = nan; % Upper bound of control input rate\nLBo = 0; % Lower bound of output\nUBo = nan; % Upper bound of output\n", "meta": {"author": "eurika-kaiser", "repo": "SINDY-MPC", "sha": "e1dfd9908b2b56af303ee9fb30a133aced4fd757", "save_path": "github-repos/MATLAB/eurika-kaiser-SINDY-MPC", "path": "github-repos/MATLAB/eurika-kaiser-SINDY-MPC/SINDY-MPC-e1dfd9908b2b56af303ee9fb30a133aced4fd757/EX_HIV_THERAPY/getMPCparams.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8615382236515259, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.599594699084812}} {"text": "function out=tanh(x)\n\nout=sinh(x)./cosh(x);\n\n", "meta": {"author": "opencobra", "repo": "cobratoolbox", "sha": "e60274d127f65d518535fd0814d20c53dc530f73", "save_path": "github-repos/MATLAB/opencobra-cobratoolbox", "path": "github-repos/MATLAB/opencobra-cobratoolbox/cobratoolbox-e60274d127f65d518535fd0814d20c53dc530f73/external/analysis/mptoolbox/@mp/tanh.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8615382094310355, "lm_q2_score": 0.6959583313396339, "lm_q1q2_score": 0.5995946946209596}} {"text": "%ADABOOSTC\n%\n% [W,V,ALF] = ADABOOSTC(A,CLASSF,N,RULE,VERBOSE);\n%\n% INPUT\n% A Dataset\n% CLASSF Untrained weak classifier\n% N Number of classifiers to be trained\n% RULE Combining rule (default: weighted voting)\n% VERBOSE Suppress progress report if 0 (default)\n%\n% OUTPUT\n% W Combined trained classifier\n% V Cell array of all classifiers\n% Use VC = stacked(V) for combining\n% ALF Weights\n%\n% DESCRIPTION\n%\n% Computation of a combined classifier according to adaboost.\n%\n% In total N weighted versions of the training set A are generated\n% iteratevely and used for the training of the specified classifier.\n% Weights, to be used for the probabilities of the objects in the training\n% set to be selected, are updated according to the Adaboost rule.\n%\n% The entire set of generated classifiers is given in V.\n% The set of classifier weigths, according to Adaboost is returned in ALF\n%\n% Various aggregating possibilities can be given in \n% the final parameter rule:\n% []: WVOTEC, weighted voting.\n% VOTEC voting\n% MEANC sum rule\n% AVERAGEC averaging of coeffients (for linear combiners)\n% PRODC product rule\n% MAXC maximum rule\n% MINC minimum rule\n% MEDIANC median rule\n%\n% REFERENCE\n% Ji Zhu, Saharon Rosset, Hui Zhou and Trevor Hastie, \n% Multiclass Adaboost. A multiclass generalization of the Adaboost \n% algorithm, based on a generalization of the exponential loss.\n% http://www-stat.stanford.edu/~hastie/Papers/samme.pdf\n%\n% SEE ALSO (PRTools Guide)\n% MAPPINGS, DATASETS\n\n% Copyright: R.P.W. Duin, r.p.w.duin@37steps.com\n% Faculty EWI, Delft University of Technology\n% P.O. Box 5031, 2600 GA Delft, The Netherlands\n% (Multiclass correction by Marcin Budka, Bournemouth Univ., UK)\n\n%function [W,V,alf] = adaboostc(a,clasf,n,rule,verbose)\nfunction [out,V,alf] = adaboostc(varargin)\n\n%% INITIALISATION\nargin = setdefaults(varargin,[],nmc,100,[],0);\nif mapping_task(argin,'definition')\n \n out = define_mapping(argin,'untrained','Adaboost');\n \n%% TRAINING\nelseif mapping_task(argin,'training')\n \n [a,clasf,n,rule,verbose] = deal(argin{:});\n [m,k,c] = getsize(a);\n V = [];\n laba = getlab(a);\n u = ones(m,1)/m;\t\t\t% initialise object weights\n alf = zeros(1,n);\t\t\t% space for classifier weights\n isseparable = 0; % check if we can make 0 error\n if verbose && k == 2\n figure(verbose);\n scatterd(a);\n end\n\n %% generate n classifiers\n for i = 1:n\n b = gendatw(a,u,m); % sample training set\n b = setprior(b,getprior(a));\t% use original priors\n w = b*clasf; % train weak classifier\n ra = a*w; % test weak classifier\n\n if verbose && k == 2\n plotc(w,1); drawnow\n end\n\t\n labc = labeld(ra);\n diff = sum(labc~=laba,2)~=0;\t% objects erroneously classified\n erra = sum((diff).*u); % weighted error on original dataset\n\n if (erra==0)\n isseparable = 1;\n V = w;\n break;\n end\n if (erra < (1-1/c)) % if classifier better then random guessing...\n alf(i) = 0.5*(log((1-erra)/erra) + log(c-1));\n correct = find(diff==0); % find correctly classified objects\n wrong = find(diff==1); % find incorrectly classified objects\n u(correct) = u(correct)*exp(-alf(i));\t% give them the ...\n u(wrong) = u(wrong)*exp(alf(i));\t \t% proper weights\n u = u./sum(u); % normalize weights\n else\n alf(i) = 0;\n end\n\t\n if verbose\n disp([erra alf(i) sum(alf)])\n end\n V = [V w]; % store all classifiers\n\n end\n\n %% combine and return\n if isseparable\n W = V;\n W = setname(W,['Boosted ',getname(V)]);\n else\n if isempty(rule)\n W = wvotec(V,alf); % default is weighted combiner\n else\n W = traincc(a,V,rule); % otherwise, use user supplied combiner\n end\n end\n\n if verbose > 0 && k == 2\n plotc(W,'r',3)\n ee = a*W*testc;\n title(['Error: ', num2str(ee)]);\n end\n \n out = W;\n\nelse\n error('Illegal call')\nend\n\nreturn\n", "meta": {"author": "marianux", "repo": "ecg-kit", "sha": "c8e3de47c54a9214138143676d2aa546b0540dd2", "save_path": "github-repos/MATLAB/marianux-ecg-kit", "path": "github-repos/MATLAB/marianux-ecg-kit/ecg-kit-c8e3de47c54a9214138143676d2aa546b0540dd2/common/prtools/adaboostc.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8615382094310357, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.5995946891879435}} {"text": "% Calculate one-shot classification error rate\nfunction run_classification\n\n classdir = 'model_refits';\n load('items_classification','nrun','ntrain','ntest','cell_Y');\n\n trainset = num2cell(vec(1:ntrain));\n testset = num2cell(vec(1:ntest));\n\n fprintf(1,'one-shot classification results\\n');\n perror = zeros(nrun,1);\n for r=1:nrun\n Y = cell_Y{r};\n fscore = @(itrain,itest) fclassify(itrain,itest,r,classdir);\n perror(r) = myclassify(trainset,testset,fscore,Y,'score');\n fprintf(1,' run %d (error %s%%)\\n',r,num2str(perror(r),3));\n end\n fprintf(1,'average error: %s%%\\n',num2str(mean(perror),3));\n\nend\n\n%\n% Bayesian classification score\n%\n% log P(I_T|I_C) + log(I_C|I_T) - log(I_C)\n% for training image I_C\n% and test image I_T\n%\n% Input\n% itrain: train index\n% itest: test index\n% irun: run index\n% classdir: file directory for \"crossFit\" files\n%\n% Output\n% log_score: [scalar] score\n%\nfunction log_score = fclassify(itrain,itest,irun,classdir)\n\n srun = num2str(irun);\n strain = num2str(itrain);\n stest = num2str(itest);\n\n fn_test_to_train = ['run',srun,'_fit_test' ,stest,'_to_image_train',strain];\n fn_train_to_test = ['run',srun,'_fit_train',strain,'_to_image_test',stest];\n\n % load file optimizing P(I_T|I_C)\n if ~exist(fullfile(classdir,[fn_train_to_test,'.mat']),'file')\n fprintf(1,'Please download pre-computed model results to use this feature. Program quiting...\\n');\n assert false;\n end\n load(fullfile(classdir,fn_train_to_test),'fit_score','prior_score');\n pair.fit_score = fit_score;\n pair.prior_score = prior_score;\n pair_fit_train_to_test = pair;\n clear pair\n \n % load file optimizing P(I_C|I_T)\n load(fullfile(classdir,fn_test_to_train),'fit_score','prior_score');\n pair.fit_score = fit_score;\n pair.prior_score = prior_score;\n pair_fit_test_to_train = pair;\n clear pair\n \n % compute score\n [log_P_IT_given_IC,prior_scores] = log_post_pred(pair_fit_train_to_test);\n log_P_IC_given_IT = log_post_pred(pair_fit_test_to_train); \n log_P_IC = logsumexp(prior_scores(:)); \n log_score = log_P_IC_given_IT + log_P_IT_given_IC - log_P_IC;\n \nend\n\n%\n% Log-posterior predictive score, log P(I_2 | I_1), using discrete approximation\n%\n% Input\n% pair: structure\n% \n% Output\n% logscore: log conditional probability\n% prior_scores: [k x 1] log joint probability (unnormalized) weights for\n% each parse of I_1\n%\nfunction [logscore,prior_scores] = log_post_pred(pair)\n\n % extra info\n logfit = pair.fit_score;\n prior_scores = pair.prior_score;\n \n % normalize weights\n logwt = prior_scores - logsumexp(prior_scores(:));\n \n % combine weights with fit term\n logv = logfit(:) + logwt;\n logscore = logsumexp(logv);\n \nend", "meta": {"author": "brendenlake", "repo": "BPL", "sha": "2c7f679bb0055f29cbade7ef099897c3342bcb79", "save_path": "github-repos/MATLAB/brendenlake-BPL", "path": "github-repos/MATLAB/brendenlake-BPL/BPL-2c7f679bb0055f29cbade7ef099897c3342bcb79/classification/run_classification.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615382165412809, "lm_q2_score": 0.6959583187272711, "lm_q1q2_score": 0.5995946887033615}} {"text": "classdef MMAE < Metric\n %MAE static class to calculate the minimum mean absolute error (MAE) per\n % class. Values range from 0 to J-1, where J is the number of classes.\n %\n % MAE methods:\n % CALCULATEMETRIC - Computes the evaluation metric\n % CALCULATECROSSVALMETRIC - Computes the evaluation metric as an error\n %\n % References:\n % [1] M. Cruz-Ram\u00edrez, C. Herv\u00e1s-Mart\u00ednez, J. S\u00e1nchez-Monedero and\n % P. A. Guti\u00e9rrez Metrics to guide a multi-objective evolutionary\n % algorithm for ordinal classification, Neurocomputing, Vol. 135, July, 2014, pp. 21-31.\n % https://doi.org/10.1016/j.neucom.2013.05.058\n %\n % This file is part of ORCA: https://github.com/ayrna/orca\n % Original authors: Pedro Antonio Guti\u00e9rrez, Mar\u00eda P\u00e9rez Ortiz, Javier S\u00e1nchez Monedero\n % Citation: If you use this code, please cite the associated paper http://www.uco.es/grupos/ayrna/orreview\n % Copyright:\n % This software is released under the The GNU General Public License v3.0 licence\n % available at http://www.gnu.org/licenses/gpl-3.0.htmlml\n methods\n function obj = MMAE()\n obj.name = 'Max Mean Absolute Error';\n end\n end\n \n methods(Static = true)\n \n %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n %\n % Function: calculateMetric (static)\n % Description: Computes the evaluation metric\n % Outputs: metric results\n % Arguments:\n % argum1--> First argument (confusion matrix or predictions)\n %\t argum2--> Second argument (true labels)\n % \t If there is only one argument, the results are computed\n %\t using the confusion matrix. In other case, with the\n %\t predictions and true labels.\n %\n %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n \n function maxmae = calculateMetric(argum1,argum2)\n %CALCULATEMETRIC Computes the evaluation metric\n % METRIC = CALCULATEMETRIC(CM) returns calculated metric from confussion\n % matrix CM\n % METRIC = CALCULATEMETRIC(actual, pred) returns calculated metric from\n % real labels (ACTUAL) labels and predicted labels (PRE\n if nargin == 2\n argum1 = confusionmat(argum1,argum2);\n end\n n=size(argum1,1);\n cm = double(argum1);\n cost = abs(repmat(1:n,n,1) - repmat((1:n)',1,n));\n mae = zeros(n:1);\n cmt = cm';\n for i=0:n-1\n mae(i+1) = sum(cost(1+(i*n):(i*n)+n).*cmt(1+(i*n):(i*n)+n)) / sum(cmt(1+(i*n):(i*n)+n));\n end\n maxmae = max(mae);\n end\n \n function value = calculateCrossvalMetric(argum1,argum2)\n %CALCULATECROSSVALMETRIC Computes the evaluation metric and returns\n %it as an error.\n % METRIC = CALCULATECROSSVALMETRIC(CM) returns calculated metric from confussion\n % matrix CM\n % METRIC = CALCULATECROSSVALMETRIC(actual, pred) returns calculated metric from\n % real labels (ACTUAL) labels and predicted labels (PRED)\n if nargin == 2\n value = MMAE.calculateMetric(argum1,argum2);\n else\n value = MMAE.calculateMetric(argum1);\n end\n end\n \n end\n \n \nend\n", "meta": {"author": "ayrna", "repo": "orca", "sha": "eaa629e687d04d73628782e16e92d330acb43faf", "save_path": "github-repos/MATLAB/ayrna-orca", "path": "github-repos/MATLAB/ayrna-orca/orca-eaa629e687d04d73628782e16e92d330acb43faf/src/Measures/MMAE.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8615381952105442, "lm_q2_score": 0.6959583250334526, "lm_q1q2_score": 0.599594679291074}} {"text": "function dist = getDistPCKh(pred,gt,refDist)\n\nassert(size(pred,1) == size(gt,1) && size(pred,2) == size(gt,2) && size(pred,3) == size(gt,3));\nassert(size(refDist,1) == size(gt,3));\n\ndist = nan(1,size(pred,2),size(pred,3));\n\nfor imgidx = 1:size(pred,3)\n \n % distance to gt joints\n dist(1,:,imgidx) = sqrt(sum((pred(:,:,imgidx) - gt(:,:,imgidx)).^2,1))./refDist(imgidx);\n\nend", "meta": {"author": "Guanghan", "repo": "GNet-pose", "sha": "c70e0fc65b290e68a16ca3040a70300f9c2bee44", "save_path": "github-repos/MATLAB/Guanghan-GNet-pose", "path": "github-repos/MATLAB/Guanghan-GNet-pose/GNet-pose-c70e0fc65b290e68a16ca3040a70300f9c2bee44/testing/eval_MPII/getDistPCKh.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8918110339361276, "lm_q2_score": 0.6723317057447908, "lm_q1q2_score": 0.5995928336483022}} {"text": "function [U_final, V_final, nIter_final, objhistory_final] = GNMF(X, k, W, options, U, V)\n% Graph regularized Non-negative Matrix Factorization (GNMF)\n%\n% where\n% X\n% Notation:\n% X ... (mFea x nSmp) data matrix \n% mFea ... number of words (vocabulary size)\n% nSmp ... number of documents\n% k ... number of hidden factors\n% W ... weight matrix of the affinity graph \n%\n% options ... Structure holding all settings\n% options.alpha ... the regularization parameter. \n% [default: 100]\n% alpha = 0, GNMF boils down to the ordinary NMF. \n% \n%\n% You only need to provide the above four inputs.\n%\n% X = U*V'\n%\n% References:\n% [1] Deng Cai, Xiaofei He, Xiaoyun Wu, and Jiawei Han. \"Non-negative\n% Matrix Factorization on Manifold\", Proc. 2008 Int. Conf. on Data Mining\n% (ICDM'08), Pisa, Italy, Dec. 2008. \n%\n% [2] Deng Cai, Xiaofei He, Jiawei Han, Thomas Huang. \"Graph Regularized\n% Non-negative Matrix Factorization for Data Representation\", IEEE\n% Transactions on Pattern Analysis and Machine Intelligence, , Vol. 33, No.\n% 8, pp. 1548-1560, 2011. \n%\n%\n% version 2.0 --April/2009 \n% version 1.0 --April/2008 \n%\n% Written by Deng Cai (dengcai AT gmail.com)\n%\n\nif min(min(X)) < 0\n error('Input should be nonnegative!');\nend\n\nif ~isfield(options,'error')\n options.error = 1e-5;\nend\nif ~isfield(options, 'maxIter')\n options.maxIter = [];\nend\n\nif ~isfield(options,'nRepeat')\n options.nRepeat = 10;\nend\n\nif ~isfield(options,'minIter')\n options.minIter = 30;\nend\n\nif ~isfield(options,'meanFitRatio')\n options.meanFitRatio = 0.1;\nend\n\nif ~isfield(options,'alpha')\n options.alpha = 100;\nend\n\nnSmp = size(X,2);\n\nif isfield(options,'alpha_nSmp') && options.alpha_nSmp\n options.alpha = options.alpha*nSmp; \nend\n\nif isfield(options,'weight') && strcmpi(options.weight,'NCW')\n feaSum = full(sum(X,2));\n D_half = X'*feaSum;\n X = X*spdiags(D_half.^-.5,0,nSmp,nSmp);\nend\n\nif ~isfield(options,'Optimization')\n options.Optimization = 'Multiplicative';\nend\n\nif ~exist('U','var')\n U = [];\n V = [];\nend\n\nswitch lower(options.Optimization)\n case {lower('Multiplicative')} \n [U_final, V_final, nIter_final, objhistory_final] = GNMF_Multi(X, k, W, options, U, V);\n otherwise\n error('optimization method does not exist!');\nend\n\n\n \n ", "meta": {"author": "ZJULearning", "repo": "MatlabFunc", "sha": "97504df0f597c1980ab76ddc0c9c5d669043c6c9", "save_path": "github-repos/MATLAB/ZJULearning-MatlabFunc", "path": "github-repos/MATLAB/ZJULearning-MatlabFunc/MatlabFunc-97504df0f597c1980ab76ddc0c9c5d669043c6c9/MatrixFactorization/GNMF.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515683, "lm_q2_score": 0.7122321964553657, "lm_q1q2_score": 0.5995753297744444}} {"text": "function [mask, weight]=mesh2mask(node,face,xi,yi,hf)\n%\n% [mask weight]=mesh2mask(node,face,Nxy)\n% or\n% [mask weight]=mesh2mask(node,face,[Nx,Ny])\n% or\n% [mask weight]=mesh2mask(node,face,xi,yi,hf)\n%\n% fast rasterization of a 2D mesh to an image with triangle index labels\n% \n% author: Qianqian Fang \n% date for initial version: July 18,2013\n%\n% input:\n% node: node coordinates, dimension N by 2 or N by 3 array\n% face: a triangle surface, N by 3 or N by 4 array\n% Nx,Ny,Nxy: output image in x/y dimensions, or both\n% xi,yi: linear vectors for the output pixel center positions in x/y\n% hf: (optional) the handle of a pre-created figure window, for faster \n% rendering\n%\n% output:\n% mask: a 2D image, the value of each pixel is the index of the\n% enclosing triangle, if the pixel is outside of the mesh, NaN\n% weight: (optional) a 3 by Nx by Ny array, where Nx/Ny are the dimensions for\n% the mask\n%\n% note: This function only works in MATLAB when the DISPLAY is not \n% disabled. The maximum size of the mask output is limited by the \n% screen size.\n%\n% example:\n%\n% [no,fc]=meshgrid6(0:5,0:5);\n% [mask weight]=mesh2mask(no,fc,-1:0.1:5,0:0.1:5);\n% imagesc(mask);\n%\n% -- this function is part of iso2mesh toolbox (http://iso2mesh.sf.net)\n%\n\nif(nargin==3 && length(xi)==1 && xi>0)\n mn=min(node);\n mx=max(node);\n df=(mx(1:2)-mn(1:2))/xi;\nelseif(nargin==3 && length(xi)==2 && all(xi>0))\n mn=min(node);\n mx=max(node);\n df=(mx(1:2)-mn(1:2))./xi;\nelseif(nargin==4 || nargin==5)\n mx=[max(xi) max(yi)];\n mn=[min(xi) min(yi)];\n df=[min(diff(xi(:))) min(diff(yi(:)))];\nelse\n error('you must give at least xi input');\nend\nif(size(node,2)<=1 || size(face,2)<=2)\n error('node must have 2 or 3 columns; face can not have less than 2 columns');\nend\n\nif(nargin<5)\n hf=figure('visible','on');\nelse\n clf(hf);\nend\npatch('Vertices',node,'Faces',face,'linestyle','none','FaceColor','flat',...\n 'FaceVertexCData',(1:size(face,1))','CDataMapping', 'scaled');\nset(gca, 'Position', [0 0 1 1]);\ncm=jet(size(face,1));\ncolormap(cm);\naxis off\nset(gca,'xlim',[mn(1) mx(1)]);\nset(gca,'ylim',[mn(2) mx(2)]);\nset(gca,'clim',[1 size(face,1)]);\n\noutput_size = round((mx(1:2)-mn(1:2))./df); %Size in pixels\n\nif(isoctavemesh || isempty(getenv('DISPLAY')))\n resolution = 300; %Resolution in DPI\n set(gcf,'PaperPositionMode','manual')\n set(gcf,'paperunits','inches','paperposition',[0 0 output_size/resolution]);\n deletemeshfile(mwpath('post_mesh2mask.png'));\n print(mwpath('post_mesh2mask.png'),'-dpng',['-r' num2str(resolution)]);\n mask=imread(mwpath('post_mesh2mask.png'));\nelse\n pos=get(hf,'position');\n pos(3:4)=max(pos(3:4),output_size+20);\n set(hf,'position',pos);\n set(gca, 'Units','pixels','position',[1, 1, output_size(1), output_size(2)]);\n mask=getframe(gca);\n if(any(size(mask.cdata)<[output_size([2 1]) 3]))\n error('the requested rasterization grid is larger than the screen resolution');\n end\n mask=mask.cdata(1:output_size(2),1:output_size(1),:);\nend\nif(nargin<5)\n close(hf);\nend\nmask=int32(reshape(mask,[size(mask,1)*size(mask,2) size(mask,3)]));\n[isfound,locb]=ismember(mask,floor(cm*255),'rows');\nlocb(isfound==0)=nan;\n\nmask=rot90(reshape(locb,output_size([2 1]))');\n\nif(nargout>=2)\n xi=mn(1)+df(1)/2:df(1):mx(1);\n yi=mn(2)+df(2)/2:df(2):mx(2);\n weight=barycentricgrid(node,face,xi,yi,mask);\n if(size(face,2)>=4)\n badidx=find(weight(1,:,:)<0 | weight(2,:,:)<0 | weight(3,:,:)<0);\n badidx=badidx(face(mask(badidx),3)~=face(mask(badidx),4));\n weight2=barycentricgrid(node,face(:,[1 3 4]),xi,yi,mask);\n weight(:,badidx)=0;\n weight([1 3 4],badidx)=weight2(:,badidx);\n end\nend\n\nfunction weight=barycentricgrid(node,face,xi,yi,mask)\n[xx,yy]=meshgrid(xi,yi);\nidx=find(~isnan(mask));\neid=mask(idx);\nt1=node(face(:,1),:);\nt2=node(face(:,2),:);\nt3=node(face(:,3),:);\ntt=(t2(:,2)-t3(:,2)).*(t1(:,1)-t3(:,1))+(t3(:,1)-t2(:,1)).*(t1(:,2)-t3(:,2));\nw(:,1)=(t2(eid,2)-t3(eid,2)).*(xx(idx)-t3(eid,1))+(t3(eid,1)-t2(eid,1)).*(yy(idx)-t3(eid,2));\nw(:,2)=(t3(eid,2)-t1(eid,2)).*(xx(idx)-t3(eid,1))+(t1(eid,1)-t3(eid,1)).*(yy(idx)-t3(eid,2));\nw(:,1)=w(:,1)./tt(eid);\nw(:,2)=w(:,2)./tt(eid);\nw(:,3)=1-w(:,1)-w(:,2);\nweight=zeros(3,size(mask,1),size(mask,2));\nww=zeros(size(mask));\nww(idx)=w(:,1);\nweight(1,:,:)=ww;\nww(idx)=w(:,2);\nweight(2,:,:)=ww;\nww(idx)=w(:,3);\nweight(3,:,:)=ww;\n", "meta": {"author": "fieldtrip", "repo": "fieldtrip", "sha": "c2039be598a02d86b39aae76bfa7aaa720f9801c", "save_path": "github-repos/MATLAB/fieldtrip-fieldtrip", "path": "github-repos/MATLAB/fieldtrip-fieldtrip/fieldtrip-c2039be598a02d86b39aae76bfa7aaa720f9801c/external/iso2mesh/mesh2mask.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515683, "lm_q2_score": 0.7122321903471563, "lm_q1q2_score": 0.599575324632397}} {"text": "function [rq,rqSS,diagnostics] = realized_quantile_variance(price,time,timeType,samplingType,samplingInterval,quantiles,blockSize,symmetric,overlap,subsamples)\n% Computes the Quantile Realized Variance of Christensen, Oomen and Podolskij (2008), the MinRV and\n% MedRV estimator of Andersen, Dobrev and Shaumberg and the general symmetrized version suggested by\n% Sheppard in a discussion of COP \n%\n% USAGE:\n% [RQ] = realized_quantile_variance(PRICE,TIME,TIMETYPE,SAMPLINGTYPE,SAMPLINGINTERVAL,QUANTILES,BLOCKSIZE)\n% [RQ,RQSS,DIAGNOSTICS] = realized_quantile_variance(PRICE,TIME,TIMETYPE,SAMPLINGTYPE,SAMPLINGINTERVAL,QUANTILES,BLOCKSIZE,SYMMETRIC,OVERLAP,SUBSAMPLES)\n%\n% INPUTS:\n% PRICE - m by 1 vector of high frequency prices\n% TIME - m by 1 vector of times where TIME(i) corresponds to PRICE(i)\n% TIMETYPE - String describing the way times are measured\n% 'wall' 24-hour clock of the form HHMMSS, e.g. 101543 or 153217\n% 'seconds' Time measured in seconds past midnight on the first day.\n% 'unit' Unit normalized date format, e.g. .1, .234, .9\n% Unit normalized times are more general than the other types and can be\n% applied to data from more than one calendar day\n% SAMPLINGTYPE - String describing the type of sampling to use when\n% filtering PRICE\n% 'CalendarTime' - Sample in calendar time using observations separated by\n% SAMPLINGINTERVAL seconds\n% 'CalendarUniform' - Sample in calendar time using SAMPLINGINTERVAL\n% observations spread uniformly between TIME(1) and TIME(m)\n% 'BusinessTime' - Sample in business (tick) time using observation separated\n% by SAMPLINGINTERVALticks\n% 'BusinessUniform' - Sample in business (tick) time using observations\n% uniformly spaced in business time.\n% 'Fixed' - Sample at specific points in time. When using fixed,\n% SAMPLINGINTERVAL must be a n by 1 vector of times with the same TIMETYPE\n% as TIME (i.e. seconds if TIME is in seconds)\n% SAMPLINGINTERVAL - Scalar integer or n by 1 vector whose meaning depends on the selected SAMPLINGTYPE\n% QUANTILES - k by 1 vector of quantile values to use when computing RQ.\n% When SYMMETRIC = false, 0.510\n error('Seven to ten inputs required.')\nend\nswitch nargin\n case 7\n symmetric = false;\n overlap = true;\n subsamples = 1;\n case 8\n overlap = true;\n subsamples = 1;\n case 9\n subsamples = 1;\nend\n\n\nif size(price,2)>size(price,1)\n price=price';\nend\nif size(price,2)>1\n error('PRICE must be a m by 1 vector.')\nend\nif size(time,2)>size(time,1)\n time=time';\nend\nif any(diff(time)<0)\n error('TIME must be sorted and increasing')\nend\nif size(time,2)>1 || length(time)~=length(price)\n error('TIME must be a m by 1 vector.')\nend\n% Inserted to protect against inputing integer times\ntime = double(time);\n\ntimeType=lower(timeType);\nif ~ismember(timeType,{'wall','seconds','unit'})\n error('TIMETYPE must be one of ''wall'', ''seconds'' or ''unit''.');\nend\nsamplingType=lower(samplingType);\nif ~ismember(samplingType,{'calendartime','calendaruniform','businesstime','businessuniform','fixed'})\n error('SAMPLINGTYPE must be one of ''CalendarTime'', ''CalendarUniform'', ''BusinessTime'', ''BusinessUniform'' or ''Fixed''.');\nend\n\nm=size(price,1);\nt0=time(1);\ntT=time(m);\nif ismember(samplingType,{'calendartime','calendaruniform','businesstime','businessuniform'})\n % Must be a scalar integer\n if ~isscalar(samplingInterval) || floor(samplingInterval)~=samplingInterval || samplingInterval<1\n error('SAMPLINGINTERVAL must be a positive integer for the SAMPLINGTYPE selected.')\n end\nelse\n if size(samplingInterval,2)>size(samplingInterval,1)\n samplingInterval=samplingInterval';\n end\n if ~(any(samplingInterval>=t0) && any(samplingInterval<=tT))\n error('At least one sampling interval must be between min(TIME) and max(TIME) when using ''Fixed'' as SAMPLINGTYPE.')\n end\n if any(diff(samplingInterval)<=0)\n error('When using ''Fixed'' as SAMPLINGTYPE the vector of sampling times in SAMPLINGINTERVAL must be sorted and strictly increasing.')\n end\nend\n\n% SAMPLERPERBIN, positive integer >=2\nif blockSize<1 || floor(blockSize)~=blockSize\n error('SAMPLESPERBIN must be a positive integer greater than or equal to 2 (and usually at least 20)')\nend\n\n% SYMMETRIC\nif isempty(symmetric)\n symmetric = false;\nend\nif ~isscalar(symmetric)\n error('SYMMETRIC must be a scalar logical value.')\nend\nsymmetric = logical(symmetric);\n\n% QUANTILES\nif symmetric\n if any(quantiles<=0) || any(quantiles>1) || length(quantiles)>blockSize || length(unique(quantiles*blockSize)) ~= length(quantiles)\n error('QUANTILES must be unique, greater than 0 and less than or equal to 1, and the number of quantiles must be smaller than SAMPLESPERBIN when SYMMETRIC = true.')\n end\nelse\n if any(quantiles<=0.5) || any(quantiles>1) || length(quantiles)>(blockSize/2) || length(unique(quantiles*blockSize)) ~= length(quantiles)\n error('QUANTILES must be unique, greater than 0.5 and less than or equal to 1, and the number of quantiles must be smaller than 0.5*SAMPLESPERBIN when SYMMETRIC = false.')\n end\nend\n\n% OVERLAP\nif isempty(overlap)\n overlap = true;\nend\nif ~isscalar(overlap)\n error('OVERLAP must be a scalar logical value.')\nend\noverlap = logical(overlap);\n\n% SUBSAMPLES\nif isempty(subsamples)\n subsamples = 1;\nend\nif ~isscalar(subsamples) || subsamples<0 || floor(subsamples)~=subsamples\n error('SUBSAMPLES must be a non-negative integer.')\nend\n\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% Input Checking\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\n% 1. Compute returns\nlogPrice = log(price);\nfilteredLogPrice = realized_price_filter(logPrice,time,timeType,samplingType,samplingInterval);\nreturns = diff(filteredLogPrice);\n% Check that the number of returns is compatible with SAMPLESPERBIN\nn=length(returns);\nif ~overlap\n if floor(n/blockSize)~=(n/blockSize)\n error(['The number of returns computed from the prices returned from realized_price_filter(PRICE,TIME,TIMETYPE,SAMPLINGTYPE,SAMPLINGINTERVAL) must be an integer multiple of SAMPLESPERBIN. The number of return produced is ' num2str(n)]);\n end\nend\n\nif overlap\n binStart = 1:n-blockSize+1;\nelse\n binStart = 1:blockSize:n;\nend\nreturns = returns * sqrt(n);\nif symmetric\n returns = abs(returns);\nend\nq = length(quantiles);\nrqindiv = zeros(length(binStart),q);\n\n\n\n% Compute the indices to use\nif symmetric\n indices = round(quantiles*blockSize);\nelse\n upperIndices = round(quantiles*blockSize);\n lowerIndices = round((1-quantiles)*blockSize+1);\nend\n% Loop over the bins\n\n\n\ncount = 1;\nfor j=binStart\n binreturns = returns(j:j+blockSize-1);\n binreturns = sort(binreturns)';\n if symmetric\n rqindiv(count,:)=binreturns(indices).^2;\n else\n rqindiv(count,:)=binreturns(lowerIndices).^2+binreturns(upperIndices).^2;\n end\n count = count + 1;\nend\nrqindiv = mean(rqindiv);\n\n[rq,rqindiv,rqcov,rqweights] = realized_quantile_variance_core(rqindiv,blockSize,quantiles,symmetric);\n\ndiagnostics.rqindiv = rqindiv;\ndiagnostics.rqcov = rqcov;\ndiagnostics.rqweights = rqweights;\n\n\nsubsampledLogPrice = realized_subsample(logPrice,time,timeType,samplingType,samplingInterval,subsamples);\nrqindiv = nan(subsamples * length(binStart),q);\ncount = 1;\nfor i=1:subsamples\n filteredLogPrice = subsampledLogPrice{i};\n returns = diff(filteredLogPrice);\n n = length(returns);\n returns = returns * sqrt(n);\n if symmetric\n returns = abs(returns);\n end\n binStart = 1:n-blockSize+1;\n for j=binStart\n binreturns = returns(j:j+blockSize-1);\n binreturns = sort(binreturns)';\n if symmetric\n rqindiv(count,:)=binreturns(indices).^2;\n else\n rqindiv(count,:)=binreturns(lowerIndices).^2+binreturns(upperIndices).^2;\n end\n count = count + 1;\n end\nend\nrqindiv = rqindiv(1:count-1,:);\nrqindiv = mean(rqindiv);\n\n[rqSS,rqindivSS] = realized_quantile_variance_core(rqindiv,blockSize,quantiles,symmetric);\ndiagnostics.rqindivSS = rqindivSS;\n\nend\n\n\nfunction [rq,rqindiv,rqcov,rqweights] = realized_quantile_variance_core(rqindiv,blockSize,quantiles,symmetric)\n\nscales = load('realized_quantile_scales');\nif symmetric\n simulationBlockSize = scales.symmetricSimulationSamplerperbin;\n simulationCovariance = scales.symmetricExpectedCovariance;\n simulationExpectedQuantiles = scales.symmetricExpectedQuantiles;\n simulationQuantile = scales.symmetricSimulationQuantile;\nelse\n simulationBlockSize = scales.asymmetricSimulationSamplerperbin;\n simulationCovariance = scales.asymmetricExpectedCovariance;\n simulationExpectedQuantiles = scales.asymmetricExpectedQuantiles;\n simulationQuantile = scales.asymmetricSimulationQuantile;\n \nend\nsimulationBlockSize = cell2mat(simulationBlockSize);\nif ismember(blockSize,simulationBlockSize )\n % If available load and use the pre-computed value\n \n \n [~,pl]=ismember(blockSize,simulationBlockSize);\n thisScale = simulationExpectedQuantiles{pl};\n thisQuantile = simulationQuantile{pl};\n thisCovariance = simulationCovariance{pl};\n q = length(quantiles);\n indicator = zeros(1,q);\n for i = 1:q\n [~,indicator(i)] = min(abs(thisQuantile-quantiles(i)));\n end\n rqExpectedSquaredQuantileValue = thisScale(indicator);\n % Find index\n rqcov = thisCovariance(indicator,indicator);\n rqCovInv = rqcov \\ eye(q);\n rqweights = rqCovInv*ones(q,1)/(ones(1,q)*rqCovInv*ones(q,1));\nelse\n % Need to simulate using 1,000,000 simulations\n if blockSize>100\n warning('oxfordRealized:realizedQuantileVariance','Computing the scales needed. Since SAMPLESPERBIN is very large this may take a long time. \\nConsider pre-computing this value, especially if using this value of SAMPLESPERBIN many times.')\n else\n warning('oxfordRealized:realizedQuantileVariance','Computing the scales needed. \\nConsider pre-computing this value, especially if using this value of SAMPLESPERBIN many times.')\n end\n [rqExpectedSquaredQuantileValue,rqweights,rqcov]=realized_quantile_variance_scale(adjSamplesPerBin,quantiles,1000000);\nend\n\n\nrqindiv = rqindiv ./ rqExpectedSquaredQuantileValue;\nrq = rqweights'*rqindiv';\nend", "meta": {"author": "bashtage", "repo": "mfe-toolbox", "sha": "9622b6c546bc6d649fd9bf0a36a7fcd53872e04a", "save_path": "github-repos/MATLAB/bashtage-mfe-toolbox", "path": "github-repos/MATLAB/bashtage-mfe-toolbox/mfe-toolbox-9622b6c546bc6d649fd9bf0a36a7fcd53872e04a/realized/realized_quantile_variance.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256551882382, "lm_q2_score": 0.7122321781307374, "lm_q1q2_score": 0.599575320001054}} {"text": "function pred_value = xval_simple_ols_featureselect(X, Y, pthreshold, holdout_method)\n% Check: a very simple leave-one-out cross-validated regression\n% pred_value = xval_simple_ols_loo(X, Y, p-value selection for univariate feature selection, holdout_method)\n%\n% pred_value: cross-validated predictions of outcome data\n% X: n x variables matrix of predictors\n% Y: n x 1 vector of outcomes\n%\n% Tor Wager, June 2010\n%\n% Go to any LASSO output directory and run this:\n% \n% maskInfo = iimg_read_img(fullfile(pwd, 'mask.img'), 2);\n% dat{1} = iimg_get_data(maskInfo, anticimages);\n% pred_value = xval_simple_ols_loo(X, Y)\n\n\n[N, k] = size(X);\npred_value = zeros(N, 1);\n\nholdout_set = nested_select_holdout_set;\n \ncreate_figure('test', 1, 2);\n\nfprintf('Fold: %03d', 0);\nfor wh_fold = 1:length(holdout_set) \n \n fprintf('\\b\\b\\b%3.0f ', wh_fold);\n \n % select training data\n Xi = X; \n Yi = Y; \n \n Yi(holdout_set{wh_fold}) = [];\n Xi(holdout_set{wh_fold}, :) = []; % leave out the missing observation(s)\n\n Xtest = X(holdout_set{wh_fold}, :);\n Ytest = Y(holdout_set{wh_fold}, :); % only used later when we test prediction\n\n ntrain = size(Xi, 1);\n nholdout = size(Xtest, 1);\n \n % select features based on univariate correlations\n [r, p, Tstat] = correlation_fast_series(Xi, Yi);\n wh_features = p <= pthreshold;\n nfeatures(wh_fold) = sum(wh_features);\n if nfeatures(wh_fold) == 0\n disp('Warning: no features pass threshold');\n wh_features = p <= prctile(p, 10);\n end\n\n Xi = Xi(:, wh_features);\n \n Xi = [ones(ntrain, 1) Xi]; % add intercept\n \n % Make prediction\n b = pinv(Xi) * Yi;\n pred_value(holdout_set{wh_fold}, 1) = [ones(nholdout, 1) Xtest(:, wh_features)] * b;\n \n create_figure('test', 1, 2, 1); subplot(1, 2, 1); plot(Xi*b, Yi, 'ko'); \n plot(pred_value(holdout_set{wh_fold}, 1), Ytest, 'ro', 'MarkerFaceColor', 'r');\n subplot(1, 2, 2); \n title('Black circles = training set; Red = holdout obs');\n drawnow;\n \nend\n\ncm = colormap(jet(N));\nfigure; hold on; \nfor i = 1:N\n plot(pred_value(i), Y(i), 'ko', 'MarkerFaceColor', cm(i, :));\nend\nxlabel('Predicted outcome (xval)'); ylabel('Outcome');\ntitle('Color = order in data series');\n\n\n\n\nfunction holdout_set = nested_select_holdout_set\n % purpose: return holdout_set variable\n\n nobs_s = length(Y);\n\n switch lower(holdout_method)\n case 'loo'\n holdout_set = cell(1, nobs_s);\n for i = 1:nobs_s, holdout_set{i} = i; end\n\n case 'l4o_covbalanced'\n disp('Selecting holdout sets: Balancing on covariates and outcome, and also trying to ensure that each obs is selected equally often.');\n holdout_proportion = 4 ./ nobs_s; % prop for leave-4-out\n nfolds = 40;\n if isempty(cov_val)\n wh_holdout = xval_select_holdout_set(Y, [], nfolds, holdout_proportion, verbose);\n else\n wh_holdout = xval_select_holdout_set(Y, cov_val, nfolds, holdout_proportion, verbose);\n end\n holdout_set = cell(1, nfolds);\n for k = 1:nfolds\n holdout_set{k} = wh_holdout(:, k);\n end\n\n case 'categorical_covs'\n \n holdout_set = xval_select_holdout_set_categoricalcovs(cov_val);\n \n case 'balanced4'\n nfolds = 4;\n holdout_set = cell(1, nfolds);\n [ys, indx] = sort(Y);\n for k = 1:nfolds\n\n holdout_set{k} = indx(k:nfolds:end);\n if isempty(holdout_set{k}), error('Holdout set construction error: Dataset too small?'); end\n\n end\n\n otherwise error('Unknown holdout method. See help.');\n end\nend\n \nend % main function\n \n", "meta": {"author": "canlab", "repo": "CanlabCore", "sha": "af242e120f0480c4feaeea90471c015a14f1f60e", "save_path": "github-repos/MATLAB/canlab-CanlabCore", "path": "github-repos/MATLAB/canlab-CanlabCore/CanlabCore-af242e120f0480c4feaeea90471c015a14f1f60e/CanlabCore/Statistics_tools/Cross_validated_Regression/xval_simple_ols_featureselect.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8418256472515684, "lm_q2_score": 0.7122321781307374, "lm_q1q2_score": 0.5995753143483024}} {"text": "% RES = corrDn(IM, FILT, EDGES, STEP, START, STOP)\n%\n% Compute correlation of matrices IM with FILT, followed by\n% downsampling. These arguments should be 1D or 2D matrices, and IM\n% must be larger (in both dimensions) than FILT. The origin of filt\n% is assumed to be floor(size(filt)/2)+1.\n% \n% EDGES is a string determining boundary handling:\n% 'circular' - Circular convolution\n% 'reflect1' - Reflect about the edge pixels\n% 'reflect2' - Reflect, doubling the edge pixels\n% 'repeat' - Repeat the edge pixels\n% 'zero' - Assume values of zero outside image boundary\n% 'extend' - Reflect and invert\n% 'dont-compute' - Zero output when filter overhangs input boundaries\n%\n% Downsampling factors are determined by STEP (optional, default=[1 1]), \n% which should be a 2-vector [y,x].\n% \n% The window over which the convolution occurs is specfied by START \n% (optional, default=[1,1], and STOP (optional, default=size(IM)).\n% \n% NOTE: this operation corresponds to multiplication of a signal\n% vector by a matrix whose rows contain copies of the FILT shifted by\n% multiples of STEP. See upConv.m for the operation corresponding to\n% the transpose of this matrix.\n\n% Eero Simoncelli, 6/96, revised 2/97.\n\nfunction res = corrDn(im, filt, edges, step, start, stop)\n\n%% NOTE: THIS CODE IS NOT ACTUALLY USED! (MEX FILE IS CALLED INSTEAD)\n\nfprintf(1,'Warning: You should compile the MEX code for \"corrDn\", found in the MEX subdirectory. It is MUCH faster.\\n');\n\n%------------------------------------------------------------\n%% OPTIONAL ARGS:\n\nif (exist('edges') == 1) \n if (strcmp(edges,'reflect1') ~= 1)\n warning('Using REFLECT1 edge-handling (use MEX code for other options).');\n end\nend\n\nif (exist('step') ~= 1)\n\tstep = [1,1];\nend\t\n\nif (exist('start') ~= 1)\n\tstart = [1,1];\nend\t\n\nif (exist('stop') ~= 1)\n\tstop = size(im);\nend\t\n\n%------------------------------------------------------------\n\n% Reverse order of taps in filt, to do correlation instead of convolution\nfilt = filt(size(filt,1):-1:1,size(filt,2):-1:1);\n\ntmp = rconv2(im,filt);\nres = tmp(start(1):step(1):stop(1),start(2):step(2):stop(2));\n", "meta": {"author": "ricedsp", "repo": "D-AMP_Toolbox", "sha": "6e597d98c84755697b65554d59485d50a549c01a", "save_path": "github-repos/MATLAB/ricedsp-D-AMP_Toolbox", "path": "github-repos/MATLAB/ricedsp-D-AMP_Toolbox/D-AMP_Toolbox-6e597d98c84755697b65554d59485d50a549c01a/Packages/BLS-GSM/Simoncelli_PyrTools/corrDn.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772450055545, "lm_q2_score": 0.6859494550081926, "lm_q1q2_score": 0.5995728098466225}} {"text": "function [b0vector b0angle] = getB0direction(vw)\n% Return the direction of the b0 field from a scan as (1) a unit vector and\n% (2) an angle in degrees\n%\n% [b0vector b0angle] = getB0direction([vw])\n%\n% Examples: \n% b0vector = getB0direction(vw)\n% [b0vector b0angle] = getB0direction\n%\n% vw can be INPLANE, GRAY, or VOLUME\n\nmrGlobals\n\nif ~exist('vw', 'var'), vw = getCurView; end\n\n% get the scanner xform (image coords => mm coords)\nscannerXform = viewGet(vw, 'scannerXform');\n\n% Define a unit vector in the z-direction in scanner space. This is the B0\n% direction (by definition).\norigin = [0 0 0]; z = [0 0 1];\n\n% Transform the vector into INPLANE image space\nb0ip = scannerXform \\ [origin 1; z 1]';\nb0ip = b0ip(1:3,2) - b0ip(1:3,1);\n\n% Make it a unit vector\nb0ip = 1/norm(b0ip) * b0ip;\n\n% xform the b0 vector to the appropriate view type\nswitch lower(viewGet(vw, 'viewType'))\n case 'inplane'\n % done\n b0vector = b0ip;\n case {'gray' 'volume'}\n xform = mrSESSION.alignment;\n b0Vol = xform * [[0 0 0 1]' [b0ip; 1]];\n % make it a vector of norm 1\n b0vector = b0Vol(1:3,2) - b0Vol(1:3,1);\n b0vector = 1/norm(b0vector) * b0vector;\n % xform to xyz\n b0vector = [-b0vector(3) b0vector(2) -b0vector(1)];\n otherwise\n error('Can''t get B0 direction in %s vw', viewGet(vw, 'viewType'))\nend\n\n% convert b0 vector into angle. This is the angle between z-vector in image\n% space and and z-vector in scanner space.\ncostheta = dot(b0vector, z)/norm(b0vector)*norm(z);\ntheta = acos(costheta);\nb0angle = theta / pi * 180;\n ", "meta": {"author": "vistalab", "repo": "vistasoft", "sha": "7f0102c696c091c858233340cc7e1ab02f064d4c", "save_path": "github-repos/MATLAB/vistalab-vistasoft", "path": "github-repos/MATLAB/vistalab-vistasoft/vistasoft-7f0102c696c091c858233340cc7e1ab02f064d4c/mrBOLD/View/getB0direction.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772351648677, "lm_q2_score": 0.6859494614282923, "lm_q1q2_score": 0.5995728087080717}} {"text": "%--------------------\nfunction [EbN, Es] = PQ_excitCB (X2)\n\npersistent W2 EIN\n\nNF = 2048;\nVersion = 'Basic';\nif (isempty (W2))\n Fs = 48000;\n f = linspace (0, Fs/2, NF/2+1);\n W2 = PQWOME (f);\n [Nc, fc] = PQCB (Version);\n EIN = PQIntNoise (fc);\nend\n\n% Allocate storage\nXwN2 = zeros (1, NF/2+1);\n\n% Outer and middle ear filtering\nXw2(1,:) = W2 .* X2(1,1:NF/2+1);\nXw2(2,:) = W2 .* X2(2,1:NF/2+1);\n\n% Form the difference magnitude signal\nfor (k = 0:NF/2)\n XwN2(k+1) = (Xw2(1,k+1) - 2 * sqrt (Xw2(1,k+1) * Xw2(2,k+1)) ...\n + Xw2(2,k+1));\nend\n\n% Group into partial critical bands\nEb(1,:) = PQgroupCB (Xw2(1,:), Version);\nEb(2,:) = PQgroupCB (Xw2(2,:), Version);\nEbN = PQgroupCB (XwN2, Version);\n\n% Add the internal noise term => \"Pitch patterns\"\nE(1,:) = Eb(1,:) + EIN;\nE(2,:) = Eb(2,:) + EIN;\n\n% Critical band spreading => \"Unsmeared excitation patterns\"\nEs(1,:) = PQspreadCB (E(1,:), Version);\nEs(2,:) = PQspreadCB (E(2,:), Version);", "meta": {"author": "stephencwelch", "repo": "Perceptual-Coding-In-Python", "sha": "2993f57570663768c02745019185091a23f021fe", "save_path": "github-repos/MATLAB/stephencwelch-Perceptual-Coding-In-Python", "path": "github-repos/MATLAB/stephencwelch-Perceptual-Coding-In-Python/Perceptual-Coding-In-Python-2993f57570663768c02745019185091a23f021fe/PEAQPython/PQevalAudioMATLAB/PQevalAudio/CB/PQ_excitCB.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772417253257, "lm_q2_score": 0.6859494550081925, "lm_q1q2_score": 0.5995728075965513}} {"text": "%% Example: Random Category Registration problem and its semidefinite relaxations\n%% Heng Yang, July 06, 2021\n\nclc; clear; close all; restoredefaultpath\n\n%% paths to dependencies\nspotpath = '../spotless';\nmosekpath = '../../mosek';\nstridepath = '../STRIDE';\nmanoptpath = '../manopt';\nsdpnalpath = '../../SDPNAL+v1.0';\npath.stridepath = stridepath;\npath.mosekpath = mosekpath;\npath.manoptpath = manoptpath;\naddpath('../utils')\naddpath('./solvers')\n\n%% choose if run GNC for STRIDE\nrungnc = true;\n\n%% generate random point cloud registration problem\ndatatype = 'car';\nproblem.outlierRatio = 0.1;\nproblem.noiseSigma = 0.01;\nproblem.translationBound = 10.0;\nswitch datatype\n case 'random'\n %%%%%%%%%%%%%% RANDOM data %%%%%%%%%%%%%%\n problem.N = 10;\n problem.K = 3;\n problem = gen_category_registration(problem);\n case 'car'\n %%%%%%%%%%%%%% PASCAL Car %%%%%%%%%%%%%%\n problem.path = './data/car.mat';\n problem = gen_catreg_pascal_car(problem);\nend\nlambda = 0.5;\n\n%% generate SDP relaxations\naddpath(genpath(spotpath))\nSDP = relax_category_registration_v2(problem,'lambda',lambda,'checkMonomials',false);\nrmpath(genpath(spotpath))\n\n%% Solve using STRIDE\n% Primal initialization\nif rungnc\n solution = gnc_category_registration(problem,SDP,path,'lambda',lambda);\n [R_est,t_est] = invert_transformation(solution.R_est,solution.t_est);\n\n v0 = lift_catreg_v2(R_est(:),...\n t_est(:),...\n solution.c_est(:),...\n solution.theta_est(:),...\n problem.cBound,...\n problem.translationBound);\n X0 = rank_one_lift(v0);\n gnc.R_err = getAngularError(problem.R_gt,solution.R_est);\n gnc.t_err = getTranslationError(problem.t_gt,solution.t_est);\n gnc.c_err = getTranslationError(problem.c_gt,solution.c_est);\n gnc.time = solution.time;\n gnc.info = solution;\n\nelse\n X0 = [];\nend\n\n% dual initialization\naddpath(genpath(spotpath))\nchordalSDP = chordal_relax_category_registration_v2(problem,'lambda',lambda);\nrmpath(genpath(spotpath))\nprob = convert_sedumi2mosek(chordalSDP.sedumi.At,...\n chordalSDP.sedumi.b,...\n chordalSDP.sedumi.c,...\n chordalSDP.sedumi.K);\naddpath(genpath(mosekpath))\ntime0 = tic;\nparam.MSK_IPAR_INTPNT_MAX_ITERATIONS = 20; % set maximum iterations 20\n[~,res] = mosekopt('minimize info',prob,param);\ntime_dualInit = toc(time0);\n[Xchordal,ychordal,Schordal,~] = recover_mosek_sol_blk(res,chordalSDP.blk);\nS_assm = catreg_dual_from_chordal_dual_v2(Schordal,problem.N,problem.K);\n\n\n% STRIDE main algorithm\naddpath(genpath(stridepath))\naddpath(genpath(manoptpath))\n\npgdopts.pgdStepSize = 10;\npgdopts.SDPNALpath = sdpnalpath;\npgdopts.maxiterPGD = 5;\n% ADMM parameters\npgdopts.tolADMM = 1e-10;\npgdopts.maxiterADMM = 1e4;\npgdopts.stopoptionADMM = 0;\n\npgdopts.rrOpt = 1:3;\npgdopts.rrFunName = 'local_search_catreg_v2';\nrrPar.blk = SDP.blk; rrPar.translationBound = problem.translationBound;\nrrPar.N = problem.N; rrPar.K = problem.K; rrPar.cBound = problem.cBound;\npgdopts.rrPar = rrPar;\npgdopts.maxiterLBFGS = 1000;\npgdopts.maxiterSGS = 1000;\npgdopts.lbfgseps = false;\npgdopts.S0 = S_assm;\n\n\n[outPGD,Xopt,yopt,Sopt] = PGDSDP(SDP.blk, SDP.At, SDP.b, SDP.C, X0, pgdopts);\nrmpath(genpath(manoptpath))\n\ninfostride = get_performance_catreg_v2(Xopt,yopt,Sopt,SDP,problem,stridepath);\ninfostride.totaltime = outPGD.totaltime + time_dualInit;\ninfostride.time = [outPGD.totaltime,time_dualInit];\nif rungnc \n infostride.gnc = gnc; \n infostride.totaltime = infostride.totaltime + gnc.time;\n infostride.time = [gnc.time,infostride.time];\nend\n\nfprintf('\\n\\n\\n\\n\\n')\n", "meta": {"author": "MIT-SPARK", "repo": "CertifiablyRobustPerception", "sha": "dd149d0c54093cfb72a8f912f4ae807635db6f3b", "save_path": "github-repos/MATLAB/MIT-SPARK-CertifiablyRobustPerception", "path": "github-repos/MATLAB/MIT-SPARK-CertifiablyRobustPerception/CertifiablyRobustPerception-dd149d0c54093cfb72a8f912f4ae807635db6f3b/CategoryRegistration/example_category_registration.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772417253256, "lm_q2_score": 0.6859494550081926, "lm_q1q2_score": 0.5995728075965513}} {"text": "classdef LossSmoothL1 < dagnn.Loss\n%LossSmoothL1 Smooth L1 loss\n% `LossSmoothL1.forward({x, x0, w})` computes the smooth L1 distance \n% between `x` and `x0`, weighting the elements by `w`.\n%\n% Here the smooth L1 loss between two vectors is defined as:\n%\n% Loss = sum_i f(x_i - x0_i) w_i.\n%\n% where f is the function (following the Faster R-CNN definition):\n%\n% { 0.5 * sigma^2 * delta^2, if |delta| < 1 / sigma^2,\n% f(delta) = {\n% { |delta| - 0.5 / sigma^2, otherwise.\n%\n% In practice, `x` and `x0` can pack multiple instances as 1 x 1 x C\n% x N arrays (or simply C x N arrays).\n\n properties\n sigma = 1.\n end\n\n methods\n function outputs = forward(obj, inputs, params)\n sigma2 = obj.sigma^2 ;\n delta = inputs{1} - inputs{2} ;\n absDelta = abs(delta) ;\n\n linearRegion = (absDelta > 1. / sigma2) ;\n absDelta(linearRegion) = absDelta(linearRegion) - 0.5/sigma2 ;\n absDelta(~linearRegion) = 0.5 * sigma2 * absDelta(~linearRegion).^2 ;\n\n % Mutliply by instance weights and sum.\n outputs{1} = inputs{3}(:)' * absDelta(:) ;\n\n % Accumulate loss statistics.\n if obj.ignoreAverage, return; end;\n n = obj.numAveraged ;\n m = n + gather(sum(inputs{3}(:))) + 1e-9 ;\n obj.average = (n * obj.average + gather(outputs{1})) / m ;\n obj.numAveraged = m ;\n end\n\n function [derInputs, derParams] = backward(obj, inputs, params, derOutputs)\n % Function derivative:\n %\n % { sigma^2 * x, if |x| < 1 / sigma^2,\n % f'(x) = {\n % { sign(x), otherwise.\n\n sigma2 = obj.sigma^2 ;\n delta = inputs{1} - inputs{2} ;\n absDelta = abs(delta) ;\n\n linearRegion = (absDelta > 1. / sigma2) ;\n delta(linearRegion) = sign(delta(linearRegion));\n delta(~linearRegion) = sigma2 * delta(~linearRegion) ;\n\n derInputs = {inputs{3} .* delta .* derOutputs{1}, [], []} ;\n derParams = {} ;\n end\n\n function obj = LossSmoothL1(varargin)\n obj.load(varargin) ;\n obj.loss = 'smoothl1';\n end\n end\nend\n", "meta": {"author": "phoenix104104", "repo": "LapSRN", "sha": "95154bba82a3aab9bdaec8e0eedd4187babc5ed2", "save_path": "github-repos/MATLAB/phoenix104104-LapSRN", "path": "github-repos/MATLAB/phoenix104104-LapSRN/LapSRN-95154bba82a3aab9bdaec8e0eedd4187babc5ed2/matconvnet/examples/fast_rcnn/+dagnn/LossSmoothL1.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772286044095, "lm_q2_score": 0.6859494614282923, "lm_q1q2_score": 0.599572804207929}} {"text": "function [ccg,ic] = chXcorr(hc_L,hc_R,fs,varargin)\n%CHXCORR Calculate cross-correlograms with a wide range of options.\n% \n% CCG = IOSR.AUDITORY.CHXCORR(HC_L,HC_R,FS) cross-correlates the input\n% 2-D matrices HC_L and HC_R over 10ms frame with a maximum lag of 1ms.\n% It is assumed that the number of frequency channels is min(size(HC_L))\n% and hence HC_L and HC_R can be in either orientation. The\n% cross-correlograms consist of cross-correlations for every frame and\n% frequency channel. CCG has dimensions [lag,frequency,frame]. The\n% function calculates running cross-correlations for every sample and\n% integrates these cross-correlations over each frame. The number of\n% frames frame_count is calculated thus:\n% \n% frame_count = ...\n% floor((max(size(hc_L))-maxlag-1)/frame_length);\n% \n% The underlying cross-correlation algorithm is based on that proposed by\n% Faller & Merimaa [1]. In this implmentation, the time constant of the\n% backward infinite exponential window is given by tau (in samples).\n% \n% CCG = IOSR.AUDITORY.CHXCORR(HC_L,HC_R,FS,'PARAMETER',VALUE) allows a\n% number of options to be specified. The options are:\n% \n% ({} indicates the default value)\n% \n% 'frame_length' : {round(0.01*fs)} | scalar\n% The length of frames used to calculate for integrating\n% cross-correlations.\n% 'noverlap' : {1} | scalar\n% The number of frames over which to integrate the\n% cross-correlations. Note that the frame count is reduced\n% accordingly.\n% 'maxlag' : {round(0.001*fs)} | scalar\n% The maximum lag of the cross-correlation.\n% 'tau' : {round(0.01*fs)} | scalar\n% The time constant of the exponential window used to calculate\n% running cross-correlations. It is recommended that if norm_flag = 1\n% then tau >> 1. As can be seen below, as tau -> 1 then \n% [aL(m,i,n?1), aR(m,i,n?1)] -> 0, and hence c(m,i,n) -> 1.\n% 'inhib' : {[]} | array\n% Specificies an array with which to multiply the cross-correlations\n% before they are integrated. The value defaults to an empty array,\n% meaning that no inhibition will be applied.\n% 'ic_t' : {0} | scalar\n% Specifies the interaural coherence (IC) threshold. Only samples for\n% which the IC exceeds this threshold will be used to integrate\n% cross-correlations. The algorithm calculates Interaural Coherence\n% (IC) according to [1]. The value should be in the range [0,1].\n% 'norm_flag' : {0} | scalar\n% Specifies whether the cross-correlograms are calculated using\n% normalised cross-correlations. A non-zero value indicates that\n% normalised cross-correlations are used.\n% 'inhib_mode' : {'subtract'} | 'multiply'\n% Specify how the inhibition is applied. The default 'subtract' will\n% subtract inhib from the running cross-correlations (negative values\n% are set to zero); 'multiply' will multiply inhib with the running\n% cross-correlations.\n% \n% [CCG,IC] = IOSR.AUDITORY.CHXCORR(...) returns the calculated IC to the\n% matrix IC. Although the matrix returned is the same size as hc_L, IC is\n% only calculated for samples 1:frame_count*frame_length, other values\n% will be set to 0.\n% \n% Algorithm\n% \n% The running normalised cross-correlation is calculated as [1]:\n% \n% C(m,i,n) = c(m,i,n) / sqrt( aL(m,i,n) * aR(m,i,n)\n% \n% where\n% \n% c(m,i,n) = (1/tau) * HC_L(i, max(n+m,n)) * HC_R(i, max(n-m,n)) + ...\n% (1-1/tau) * c(m,i,n-1),\n% \n% aL(m,i,n) = (1/tau) * (HC_L(i, max(n+m,n)))^2 + ...\n% (1-1/tau) * aL(m,i,n-1),\n% \n% aR(m,i,n) = (1/tau) * (HC_R(i, max(n+m,n)))^2 + ...\n% (1-1/tau) * aR(m,i,n-1),\n% \n% i is the frequency index, m is the lag index, and n is the sample\n% index. The running (non-normalised) cross-correlation is calculated is\n% simply c(m,i,n).\n% \n% The interaural coherence is\n% \n% IC(i,n) = max(C(m,i,n)) % (i.e. over m)\n% \n% The cross-correlogram is calculated as the sum of cross- correlations\n% in a given frame:\n% \n% CCG(m,i,j) = sum(C(m,i,J),3)\n% \n% where\n% \n% J = (j-1) * frame_length + 1 : j * frame_length\n% \n% References\n% \n% [1] C. Faller and J. Merimaa, \"Source localization in complex listening\n% situations: Selection of binaural cues based on interaural\n% coherence\", The Journal of the Acoustical Society of America, vol.\n% 116, pp.3075-3089, Nov. 2004.\n% \n% Further Reading\n% \n% C. Hummersone, R. Mason, and T. Brookes, \"A comparison of computational\n% precedence models for source separation in reverberant\n% environments\", The Journal of the Audio Engineering Society, vol.\n% 61(7/8), pp.508-520, July 2013.\n\n% Copyright 2016 University of Surrey.\n\n assert(nargin>=3, 'iosr:chXcorr:nargin', 'Number of input arguments must be greater than or equal to three.')\n\n if isparameter(varargin,'inhib_mode') && ~isparameter(varargin,'inhib')\n warning('iosr:instIld:inhibMode','''inhib_mode'' specified, but no inhibition array ''inhib''.');\n end\n\n % Check source file is compiled\n iosr.general.checkMexCompiled('-largeArrayDims',fullfile(fileparts(mfilename('fullpath')),'chXcorr_c.c'))\n\n options = struct(...\n 'frame_length',round(0.01*fs),...\n 'noverlap',1,...\n 'maxlag',round(0.001*fs),...\n 'tau',round(0.01*fs),...\n 'inhib',[],...\n 'ic_t',0,...\n 'norm_flag',0,...\n 'inhib_mode','subtract');\n\n % read parameter/value inputs\n if nargin > 3 % if parameters are specified\n % read the acceptable names\n optionNames = fieldnames(options);\n % count arguments\n nArgs = length(varargin);\n if round(nArgs/2)~=nArgs/2\n error('iosr:chXcorr:nameValuePair','CHXCORR needs propertyName/propertyValue pairs')\n end\n % overwrite defults\n for pair = reshape(varargin,2,[]) % pair is {propName;propValue}\n IX = strcmpi(pair{1},optionNames); % find match parameter names\n if any(IX)\n % do the overwrite\n options.(optionNames{IX}) = pair{2};\n else\n error('iosr:chXcorr:unknownOption','%s is not a recognized parameter name',pair{1})\n end\n end\n end\n\n % assign options to variables\n frame_length = options.frame_length;\n noverlap = options.noverlap;\n maxlag = options.maxlag;\n tau = options.tau;\n inhib_mode = options.inhib_mode;\n norm_flag = options.norm_flag;\n ic_t = options.ic_t;\n inhib = options.inhib;\n\n % check inputs\n assert(all(size(hc_L)==size(hc_R)), 'iosr:chXcorr:invalidInput', '''hc_L'' and ''hc_R'' must be the same size')\n assert(round(frame_length)==frame_length && isscalar(frame_length) && frame_length>0, 'iosr:chXcorr:invalidFrame', ...\n '''frame_length'' must be an integer greater than zero')\n assert(round(noverlap)==noverlap && isscalar(noverlap) && noverlap>0, 'iosr:chXcorr:invalidNoverlap', ...\n '''noverlap'' must be an integer greater than zero')\n assert(round(maxlag)==maxlag && isscalar(maxlag) && maxlag>0, 'iosr:chXcorr:invalidMaxlag', ...\n '''maxlag'' must be an integer greater than zero')\n assert(isscalar(tau) && tau>=1, 'iosr:chXcorr:invalidTau', '''tau'' must be a scalar greater than or equal to one')\n assert(isscalar(norm_flag), 'iosr:chXcorr:invalidNorm', '''norm_flag'' must be a scalar')\n assert(isscalar(ic_t) && ic_t>=0 && ic_t<=1, 'iosr:chXcorr:invalidIct', '''ic_t'' must be a scalar in the range [0,1]')\n assert(ischar(inhib_mode), 'iosr:chXcorr:invalidInhibMode', '''inhib_mode'' must be a char array (string)')\n\n % Calculate frame count\n frame_count = floor(max(size(hc_L))/(frame_length));\n frame_count = frame_count-noverlap+1;\n\n % Calculate number of frequency channels\n numchans = min(size(hc_L));\n numsamples = max(size(hc_L));\n\n % Check orientation of HC and inhib data (i.e. that frequency runs across the rows)\n dims = size(hc_L);\n hc_L = check_input(hc_L,2,numchans);\n hc_R = check_input(hc_R,2,numchans);\n\n % set a flag if data has been transposed in this way\n if dims(1)~=size(hc_L,1)\n rot = true;\n else\n rot = false;\n end\n\n % set inhibition mode ID\n switch inhib_mode\n case 'multiply'\n inhib_mode_ID = 1;\n if isempty(inhib)\n inhib = ones(size(hc_L));\n end\n case 'subtract'\n inhib_mode_ID = 2;\n if isempty(inhib)\n inhib = zeros(size(hc_L));\n end\n otherwise\n error('iosr:chXcorr:unknownInhibMode','''inhib_mode'' must be set to ''multiply'' or ''subtract''')\n end\n\n inhib = check_input(inhib,2,numchans);\n\n % Append HC and inhibition data with zeros for cross-correlation\n hc_L = [hc_L; zeros(maxlag+1,numchans)];\n hc_R = [hc_R; zeros(maxlag+1,numchans)];\n inhib = [inhib; zeros(maxlag+1,numchans)];\n\n assert(all(size(inhib)==size(hc_L)), 'iosr:chXcorr:invalidInhib', '''inhib'' must be a matrix the same size as ''hc_L'' or ''hc_R''')\n\n % Calculate cross-correlograms\n [ccg,ic] = iosr.auditory.chXcorr_c(hc_L,hc_R,frame_count,frame_length,noverlap,maxlag,tau,inhib,ic_t,norm_flag,inhib_mode_ID);\n\n % Correct orientation of IC data, if data was transposed, and crop to remove appended zeros\n ic = ic(1:numsamples,:);\n if rot\n ic = ic';\n end\n\nend\n\nfunction output = check_input(input,dim,target)\n%CHECK_INPUT check input is correct orientation\n\n if size(input,dim)~=target\n output = input';\n assert(size(output,dim)==target, 'iosr:chXcorr:invalidInputs', 'Input invalid')\n else\n output = input;\n end\n\nend\n\nfunction set = isparameter(input,parameter)\n%ISPARAMETER check for input parameter\n\n set = any(strcmpi(input(cellfun(@ischar,input)),parameter));\n\nend\n", "meta": {"author": "IoSR-Surrey", "repo": "MatlabToolbox", "sha": "4bff1bb2da7c95de0ce2713e7c710a0afa70c705", "save_path": "github-repos/MATLAB/IoSR-Surrey-MatlabToolbox", "path": "github-repos/MATLAB/IoSR-Surrey-MatlabToolbox/MatlabToolbox-4bff1bb2da7c95de0ce2713e7c710a0afa70c705/+iosr/+auditory/chXcorr.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8740772286044095, "lm_q2_score": 0.6859494550081925, "lm_q1q2_score": 0.599572798596266}} {"text": "function varargout = cosh(varargin)\n%COSH Hyperbolic cosine of a DISKFUN.\n% COSH(F) returns the hyperbolic cosine of F.\n% \n% See also DISKFUN/SINH, DISKFUN/COS.\n\n% Copyright 2017 by The University of Oxford and The Chebfun Developers.\n% See http://www.chebfun.org/ for Chebfun information.\n\n[varargout{1:nargout}] = cosh@separableApprox(varargin{:});\n\nend\n", "meta": {"author": "chebfun", "repo": "chebfun", "sha": "8c49396a55e46ddd57a1d108c6a8f32e37536d54", "save_path": "github-repos/MATLAB/chebfun-chebfun", "path": "github-repos/MATLAB/chebfun-chebfun/chebfun-8c49396a55e46ddd57a1d108c6a8f32e37536d54/@diskfun/cosh.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8740772286044095, "lm_q2_score": 0.6859494485880927, "lm_q1q2_score": 0.599572792984603}} {"text": "%% CS294A/CS294W Linear Decoder Exercise\n\n% Instructions\n% ------------\n%\n% This file contains code that helps you get started on the\n% linear decoder exericse. For this exercise, you will only need to modify\n% the code in sparseAutoencoderLinearCost.m. You will not need to modify\n% any code in this file.\n\naddpath '../library/'\naddpath '../library/minFunc/'\n\n%%======================================================================\n%% STEP 0: Initialization\n% Here we initialize some parameters used for the exercise.\n\nimageChannels = 3; % number of channels (rgb, so 3)\n\npatchDim = 8; % patch dimension\nnumPatches = 100000; % number of patches\n\nvisibleSize = patchDim * patchDim * imageChannels; % number of input units\noutputSize = visibleSize; % number of output units\nhiddenSize = 400; % number of hidden units\n\nsparsityParam = 0.035; % desired average activation of the hidden units.\nlambda = 3e-3; % weight decay parameter\nbeta = 5; % weight of sparsity penalty term\n\nepsilon = 0.1;\t % epsilon for ZCA whitening\n\n% %%======================================================================\n% %% STEP 1: Create and modify sparseAutoencoderLinearCost.m to use a linear decoder,\n% % and check gradients\n% % You should copy sparseAutoencoderCost.m from your earlier exercise\n% % and rename it to sparseAutoencoderLinearCost.m.\n% % Then you need to rename the function from sparseAutoencoderCost to\n% % sparseAutoencoderLinearCost, and modify it so that the sparse autoencoder\n% % uses a linear decoder instead. Once that is done, you should check\n% % your gradients to verify that they are correct.\n%\n% % NOTE: Modify sparseAutoencoderCost first!\n%\n% % To speed up gradient checking, we will use a reduced network and some\n% % dummy patches\n% hiddenSize = 5;\n% visibleSize = 8;\n% patches = rand([8 10]);\n% theta = initializeParameters(hiddenSize, visibleSize);\n%\n% [cost, grad] = sparseAutoencoderLinearCost(theta, visibleSize, hiddenSize, ...\n% lambda, sparsityParam, beta, ...\n% patches);\n%\n% % Check gradients\n% numGrad = computeNumericalGradient( @(x) sparseAutoencoderLinearCost(x, visibleSize, hiddenSize, ...\n% lambda, sparsityParam, beta, ...\n% patches), theta);\n%\n% % Use this to visually compare the gradients side by side\n% disp([numGrad grad]);\n%\n% diff = norm(numGrad-grad)/norm(numGrad+grad);\n% % Should be small. In our implementation, these values are usually less than 1e-9.\n% disp(diff);\n%\n% assert(diff < 1e-9, 'Difference too large. Check your gradient computation again');\n%\n% % NOTE: Once your gradients check out, you should run step 0 again to\n% % reinitialize the parameters\n% %}\n\n%%======================================================================\n%% STEP 2: Learn features on small patches\n% In this step, you will use your sparse autoencoder (which now uses a\n% linear decoder) to learn features on small patches sampled from related\n% images.\n\n%% STEP 2a: Load patches\n% In this step, we load 100k patches sampled from the STL10 dataset and\n% visualize them.\n\npatches = load('../data/STL10Patches100k.mat');\npatches = patches.patches;\n\ndisplayColorNetwork(patches(:, 1:100));\n\n\n%% STEP 2b: Apply preprocessing\n% In this sub-step, we preprocess the sampled patches, in particular,\n% ZCA whitening them.\n%\n% In a later exercise on convolution and pooling, you will need to replicate\n% exactly the preprocessing steps you apply to these patches before\n% using the autoencoder to learn features on them. Hence, we will save the\n% ZCA whitening and mean image matrices together with the learned features\n% later on.\n\n% Scale data to range [0, 1]\npatches = patches / 255;\n\n% Subtract mean patch (hence zeroing the mean of the patches)\nmeanPatch = mean(patches, 2);\npatches = bsxfun(@minus, patches, meanPatch);\n\n% Apply ZCA whitening\nsigma = patches * patches' / numPatches;\n[u, s, v] = svd(sigma);\nZCAWhite = u * diag(1 ./ (diag(s) + epsilon)) * u';\npatches = ZCAWhite * patches;\n\ndisplayColorNetwork(patches(:, 1:100));\n\n%% STEP 2c: Learn features\n% You will now use your sparse autoencoder (with linear decoder) to learn\n% features on the preprocessed patches. This should take around 45 minutes.\n\ntheta = initializeParameters(hiddenSize, visibleSize);\n\n% Use minFunc to minimize the function\n\nclear('options');\noptions.Method = 'lbfgs';\noptions.maxIter = 400;\noptions.display = 'on';\n\n[optTheta, cost] = minFunc( @(p) sparseAutoencoderLinearCost(p, ...\n visibleSize, hiddenSize, ...\n lambda, sparsityParam, ...\n beta, patches), ...\n theta, options);\n\n% Save the learned features and the preprocessing matrices for use in\n% the later exercise on convolution and pooling\nfprintf('Saving learned features and preprocessing matrices...\\n');\nsave('STL10Features.mat', 'optTheta', 'ZCAWhite', 'meanPatch');\nfprintf('Saved\\n');\n\n%% STEP 2d: Visualize learned features\n\nW = reshape(optTheta(1:visibleSize * hiddenSize), hiddenSize, visibleSize);\nb = optTheta(2*hiddenSize*visibleSize+1:2*hiddenSize*visibleSize+hiddenSize);\ndisplayColorNetwork(W');\n", "meta": {"author": "zellyn", "repo": "deeplearning-class-2011", "sha": "d44b6c8695baa0d80b9fea21538f877e6d2eaddb", "save_path": "github-repos/MATLAB/zellyn-deeplearning-class-2011", "path": "github-repos/MATLAB/zellyn-deeplearning-class-2011/deeplearning-class-2011-d44b6c8695baa0d80b9fea21538f877e6d2eaddb/ufldl/linear_decoder_exercise/linearDecoderExercise.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085909370422, "lm_q2_score": 0.7634837689358857, "lm_q1q2_score": 0.5995703627863427}} {"text": "function c = nancov(x,varargin)\n%NANCOV Covariance matrix, ignoring NaNs.\n% C = NANCOV(X), if X is a vector, returns the sample variance of the\n% values in X, treating NaNs as missing values. For matrices, where\n% each row is an observation and each column a variable, NANCOV(X) is\n% the covariance matrix computing using rows of X that do not contain\n% any NaN values. NANCOV(X,Y), where X and Y are matrices with\n% the same number of elements, is equivalent to NANCOV([X(:) Y(:)]). \n% \n% NANCOV(X) or NANCOV(X,Y) normalizes by (N-1) if N>1, where N is the\n% number of observations after removing missing values. This makes\n% NANCOV(X) the best unbiased estimate of the covariance matrix if the\n% observations are from a normal distribution. For N=1, COV normalizes\n% by N.\n%\n% NANCOV(X,1) or NANCOV(X,Y,1) normalizes by N and produces the second\n% moment matrix of the observations about their mean. NANCOV(X,Y,0) is\n% the same as NANCOV(X,Y), and NANCOV(X,0) is the same as NANCOV(X).\n%\n% C = NANCOV(...,'pairwise') computes C(I,J) using rows with no NaN\n% values in columns I or J. The result may not be a positive definite\n% matrix. C = NANCOV(...,'complete') is the default, and it omits rows\n% with any NaN values, even if they are not in column I or J.\n%\n% The mean is removed from each column before calculating the\n% result.\n%\n% Example: Generate random data having non-zero covariance between\n% column 4 and the other columns.\n% x = randn(30,4); % uncorrelated data\n% x(:,4) = sum(x,2); % introduce correlation\n% x(2,3) = NaN; % introduce one missing value\n% c = nancov(x) % compute sample covariance\n%\n% Class support for inputs X,Y:\n% float: double, single\n%\n% See also COV, VAR, NANVAR.\n\n% Copyright 1984-2011 The MathWorks, Inc.\n% $Revision: 1.1.8.3 $ $Date: 2011/02/09 19:35:29 $\n\nif nargin<1\n error(message('stats:nancov:NotEnoughInputs'));\nend\n\n% Should we ignore NaNs by complete rows or pairwise?\ndopairwise = false;\nif numel(varargin)>0\n temp = varargin{end};\n if ischar(temp)\n j = find(strncmpi(temp, {'pairwise' 'complete'},length(temp)));\n if isempty(j)\n error(message('stats:nancov:InvalidArg', temp));\n end\n dopairwise = (j==1);\n varargin(end) = [];\n end\nend\n\n% Should we use the mle (divide by N) or unbiased estimate (N-1)?\ndomle = false;\nif numel(varargin)>0\n temp = varargin{end};\n if isequal(temp,0) || isequal(temp,1)\n domle = (temp==1);\n varargin(end) = [];\n end\nend\n\nif numel(varargin)>1\n error(message('stats:nancov:TooManyArgs'));\nend\n\nscalarxy = false; % nancov(scalar,scalar) is an ambiguous case\nif numel(varargin)>0\n y = varargin{1};\n\n % Two inputs, convert to equivalent single input\n x = x(:);\n y = y(:);\n if length(x)~=length(y)\n error(message('stats:nancov:XYmismatch'));\n end\n scalarxy = isscalar(x) && isscalar(y);\n x = [x y];\nelseif ndims(x)>2\n error(message('stats:nancov:InputDim'));\nend\n\nif isvector(x) && ~scalarxy\n x = x(:);\nend\n\nxnan = isnan(x);\n[m,n] = size(x);\n\nif isempty(x);\n if (m==0 && n==0)\n c = NaN(class(x));\n else\n c = NaN(n,class(x));\n end\n return;\nend\n\nif ~dopairwise || ~any(any(xnan)) % no need to do pairwise\n nanrows = any(xnan,2);\n if any(nanrows)\n x = x(~nanrows,:);\n end\n c = localcov(x,domle);\nelse % pairwise with some NaNs\n % Compute variance using complete data separately by column\n c = zeros(n,class(x));\n x(xnan) = 0;\n colsize = sum(~xnan,1);\n xmean = sum(x,1) ./ max(1,colsize);\n xmean(colsize==0) = NaN;\n xc = x - repmat(xmean,m,1);\n xc(xnan) = 0;\n xvar = sum(xc.^2,1);\n if domle\n denom = colsize;\n else\n denom = max(0,colsize-1);\n end\n xvar(denom>1) = xvar(denom>1) ./ denom(denom>1);\n xvar(denom==0) = NaN;\n c(1:n+1:end) = xvar;\n\n % Now compute off-diagonal entries\n jk = 1:2;\n for j = 2:n\n jk(1) = j;\n for k=1:j-1\n jk(2) = k;\n rowsjk = ~any(xnan(:,jk),2);\n njk = sum(rowsjk);\n if njk<=1\n cjk = NaN;\n else\n cjk = localcov(x(rowsjk,jk),domle);\n cjk = cjk(1,2);\n end\n c(j,k) = cjk;\n end\n end\n c = c + tril(c,-1)';\nend\n\n% ------------------------------------------------\nfunction [c,n] = localcov(x,domle)\n%LOCALCOV Compute cov with no error checking and assuming NaNs are removed\n\n[m,n] = size(x);\nif domle\n denom = m;\nelse\n denom = max(0,m-1);\nend\n\nif m==1 % and doing mle, be sure to get exact 0\n c = zeros(n,class(x));\nelseif denom==0\n c = NaN(n,class(x));\nelse\n xc = x - repmat(mean(x),m,1);\n c = xc' * xc / denom;\nend\n\n", "meta": {"author": "marianux", "repo": "ecg-kit", "sha": "c8e3de47c54a9214138143676d2aa546b0540dd2", "save_path": "github-repos/MATLAB/marianux-ecg-kit", "path": "github-repos/MATLAB/marianux-ecg-kit/ecg-kit-c8e3de47c54a9214138143676d2aa546b0540dd2/common/wavedet/nancov.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.7853085808877581, "lm_q2_score": 0.7634837635542925, "lm_q1q2_score": 0.5995703508876661}} {"text": "function varargout = calcTensor(odf,T,varargin)\n% compute the average tensor for an ODF\n%\n% Syntax\n% [TVoigt, TReuss, THill] = calcTensor(odf,T)\n% THill = calcTensor(odf,T,'Hill')\n% TGeo = calcTensor(odf,T,'geometric')\n%\n% Input\n% odf - @SO3Fun\n% T - @tensor\n%\n% Output\n% T - @tensor\n%\n% Options\n% Voigt - Boigt mean\n% Reuss - Reuss mean\n% Hill - Hill mean\n% geometric - geometric mean\n%\n% See also\n% tensor/mean EBSD/calcTensor\n\n% decide between the quadrature based method and the harmonic method\nif ~check_option(varargin,'quadrature')\n\n % the harmonic route is directly implemented into tensor/mean\n [varargout{1:nargout}] = mean(T,odf,varargin{:});\n\nelse % quadrature based method\n\n % define a grid\n res = get_option(varargin,'resolution',2.5*degree);\n S3G = equispacedSO3Grid(odf.CS,odf.SS,'resolution',res);\n\n % evaluate the ODF\n f = eval(odf,S3G,varargin{:});\n f = f ./ sum(f(:));\n\n % compute the means\n [varargout{1:nargout}] = mean(S3G*T,'weights',f(:),varargin{:});\n\nend\n\nend\n", "meta": {"author": "mtex-toolbox", "repo": "mtex", "sha": "f0ce46a720935e9ae8106ef919340534bca1adcb", "save_path": "github-repos/MATLAB/mtex-toolbox-mtex", "path": "github-repos/MATLAB/mtex-toolbox-mtex/mtex-f0ce46a720935e9ae8106ef919340534bca1adcb/SO3Fun/@SO3Fun/calcTensor.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8872045937171068, "lm_q2_score": 0.6757646075489392, "lm_q1q2_score": 0.5995414640888567}} {"text": "function [nrm] = normals(pnt, tri, opt)\n\n% NORMALS compute the surface normals of a triangular mesh\n% for each triangle or for each vertex\n%\n% Use as\n% [nrm] = normals(pnt, tri, opt)\n% where opt is either 'vertex' (default) or 'triangle'.\n%\n% See also PCNORMALS, PROJECTTRI\n\n% Copyright (C) 2002-2007, Robert Oostenveld\n%\n% This file is part of FieldTrip, see http://www.fieldtriptoolbox.org\n% for the documentation and details.\n%\n% FieldTrip is free software: you can redistribute it and/or modify\n% it under the terms of the GNU General Public License as published by\n% the Free Software Foundation, either version 3 of the License, or\n% (at your option) any later version.\n%\n% FieldTrip is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU General Public License for more details.\n%\n% You should have received a copy of the GNU General Public License\n% along with FieldTrip. If not, see .\n%\n% $Id$\n\nif nargin<3\n opt='vertex';\nelseif (opt(1)=='v' || opt(1)=='V')\n opt='vertex';\nelseif (opt(1)=='t' || opt(1)=='T')\n opt='triangle';\nelse\n ft_error('invalid optional argument');\nend\n\nnpnt = size(pnt,1);\nntri = size(tri,1);\n\n% shift to center\npnt(:,1) = pnt(:,1)-mean(pnt(:,1),1);\npnt(:,2) = pnt(:,2)-mean(pnt(:,2),1);\npnt(:,3) = pnt(:,3)-mean(pnt(:,3),1);\n\n% compute triangle normals\n% nrm_tri = zeros(ntri, 3);\n% for i=1:ntri\n% v2 = pnt(tri(i,2),:) - pnt(tri(i,1),:);\n% v3 = pnt(tri(i,3),:) - pnt(tri(i,1),:);\n% nrm_tri(i,:) = cross(v2, v3);\n% end\n\n% vectorized version of the previous part\nv2 = pnt(tri(:,2),:) - pnt(tri(:,1),:);\nv3 = pnt(tri(:,3),:) - pnt(tri(:,1),:);\nnrm_tri = cross(v2, v3);\n\n\nif strcmp(opt, 'vertex')\n % compute vertex normals\n nrm_pnt = zeros(npnt, 3);\n for i=1:ntri\n nrm_pnt(tri(i,1),:) = nrm_pnt(tri(i,1),:) + nrm_tri(i,:);\n nrm_pnt(tri(i,2),:) = nrm_pnt(tri(i,2),:) + nrm_tri(i,:);\n nrm_pnt(tri(i,3),:) = nrm_pnt(tri(i,3),:) + nrm_tri(i,:);\n end\n % normalise the direction vectors to have length one\n nrm = nrm_pnt ./ (sqrt(sum(nrm_pnt.^2, 2)) * ones(1,3));\nelse\n % normalise the direction vectors to have length one\n nrm = nrm_tri ./ (sqrt(sum(nrm_tri.^2, 2)) * ones(1,3));\nend\n\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% fast cross product to replace the MATLAB standard version\nfunction [c] = cross(a,b)\nc = [a(:,2).*b(:,3)-a(:,3).*b(:,2) a(:,3).*b(:,1)-a(:,1).*b(:,3) a(:,1).*b(:,2)-a(:,2).*b(:,1)];\n\n", "meta": {"author": "spm", "repo": "spm12", "sha": "3085dac00ac804adb190a7e82c6ef11866c8af02", "save_path": "github-repos/MATLAB/spm-spm12", "path": "github-repos/MATLAB/spm-spm12/spm12-3085dac00ac804adb190a7e82c6ef11866c8af02/external/fieldtrip/forward/private/normals.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8872045907347108, "lm_q2_score": 0.6757646075489392, "lm_q1q2_score": 0.599541462073459}} {"text": "function fk_space = autoGen_fk_space(q1,q2,q3)\n%AUTOGEN_FK_SPACE\n% FK_SPACE = AUTOGEN_FK_SPACE(Q1,Q2,Q3)\n\n% This function was generated by the Symbolic Math Toolbox version 8.4.\n% 01-Jun-2020 11:59:03\n\nt2 = cos(q1);\nt3 = cos(q2);\nt4 = sin(q1);\nt5 = q2+q3;\nt6 = cos(t5);\nt7 = sin(t5);\nt8 = t3.*(4.0./2.5e+1);\nt9 = t6.*(5.7e+1./2.0e+2);\nt10 = t8+t9;\nfk_space = reshape([t2.*t6,t4.*t6,-t7,0.0,-t4,t2,0.0,0.0,t2.*t7,t4.*t7,t6,0.0,t2.*t10,t4.*t10,t7.*(-5.7e+1./2.0e+2)-sin(q2).*(4.0./2.5e+1),1.0],[4,4]);\n", "meta": {"author": "ShuoYangRobotics", "repo": "QuadrupedSim", "sha": "8427715395b63bddb77329e66f7484e529998445", "save_path": "github-repos/MATLAB/ShuoYangRobotics-QuadrupedSim", "path": "github-repos/MATLAB/ShuoYangRobotics-QuadrupedSim/QuadrupedSim-8427715395b63bddb77329e66f7484e529998445/autoGen_fk_space.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8872045847699186, "lm_q2_score": 0.6757646075489392, "lm_q1q2_score": 0.5995414580426636}} {"text": "function [varargout, peval] = separcomp(dpix, peval, winit_pix, hinit)\n% separcomp(dpix, p_script, savethis, winit, hinit)\n% separate components\n% V ~ WH\n% V -> N_pix x N_t\n% W -> N_pix x N_comp - xth pixel of the ith components\n% H -> N_copm x N_t - contribution of the i-th component in the time t\n\n[peval.nx, peval.ny, peval.nt] = size(dpix);\npeval.numpix = peval.nx*peval.ny;\npeval.meandata = mean(dpix(:));\n\ndvec = reshape(dpix,peval.numpix, peval.nt);\ndpix_dip = dip_image(dpix);\n\n% background subtraction with empirical values:\npeval.bg_clip = 'no'; \npeval.bg_fs_var = 5; \npeval.bg_perc = 20; \npeval.bg_ob_dist = 8;\nif ~isfield(peval, 'bg')\n [out_nobg, peval.bg, bg_im]=backgroundoffset(dpix_dip, peval.bg_clip, peval.bg_fs_var, peval.bg_perc, peval.bg_ob_dist);\nend\n\nif ~isfield(peval, 'ncomp')\n peval.ncomp=estimate_ncpomp(dvec);\nend\n\n[winit, hinit] = initwh(winit_pix, hinit, peval); %initialization of w and h\n\n\n\nif ~isfield(peval, 'w_fixvec') peval.w_fixvec=[]; end\nif ~isfield(peval, 'h_fixvec') peval.h_fixvec=[]; end\n\nif isempty(peval.w_fixvec)\n peval.w_fixvec = peval.ncomp + 1; %fixing background component\nelseif ~(peval.w_fixvec(end) == peval.ncomp + 1)\n peval.w_fixvec = [peval.w_fixvec, peval.ncomp + 1];\nend\n\nif isempty(peval.h_fixvec)\n peval.h_fixvec = peval.ncomp + 1; %fixing background component\nelseif ~(peval.h_fixvec(end) == peval.ncomp + 1)\n peval.h_fixvec = [peval.h_fixvec, peval.ncomp + 1];\nend\n\nverbose = 1;\n% if strcmp (peval.method, 'nmf_classic') %classical nmf updates \n% [w,h,peval, dtrace, htrace]=nmf_classic(dvec,winit,hinit,peval,verbose);\n% elseif strcmp (peval.method, 'nmf_conjgrad_penalty') %classical nmf updates\n% [w,h,peval, dtrace, htrace]=nmf_conjgrad_penalty(dvec,winit,hinit,peval,verbose);\n% end\neval (['[w,h,peval, dtrace, htrace]=' peval.method '(dvec,winit,hinit,peval,verbose);']);\n\nvarargout = struct('w',w,'h',h, 'dtrace', dtrace, 'htrace', htrace);", "meta": {"author": "aludnam", "repo": "MATLAB", "sha": "020b5cb02cc843e09a0ed689589382f18cce5e6d", "save_path": "github-repos/MATLAB/aludnam-MATLAB", "path": "github-repos/MATLAB/aludnam-MATLAB/MATLAB-020b5cb02cc843e09a0ed689589382f18cce5e6d/separ/separcomp_penalty.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045966995027, "lm_q2_score": 0.6757645944891558, "lm_q1q2_score": 0.5995414545175545}} {"text": "%% INS\u60ef\u5bfc\u89e3\u7b97\nclear;\nclc;\nclose all;\n\n%% \nFs = 100; %\u91c7\u6837\u9891\u7387\nN = 1000; %\u91c7\u6837\u6b21\u6570\n\ndt = 1 / Fs;\ngyr = [0.01, 0.02, 0.03]; %\u5355\u4f4drad\nacc = [0, 0, 9.8]; % \u5355\u4f4dm/s^(2)\n\n% \u6377\u8054\u60ef\u5bfc\u89e3\u7b97\np = zeros(3, 1);\nv = zeros(3, 1);\nq= [1 0 0 0]';\n\nfor i=1:N\n [p ,v, q] = ch_nav_equ_local_tan(p, v, q, acc', gyr' , dt, [0, 0, -9.8]');\n h_pos(i,:) = p;\n h_vel(i,:) = v;\n h_eul(i,:) = ch_q2eul(q);\nend\n\nfigure;\nsubplot(2,2,1);\nch_plot_pos3d(h_pos);\nsubplot(2,2,2);\nch_plot_pos2d(h_pos);\nsubplot(2,2,3);\nch_plot_att(h_eul);\n\nfprintf('\u7eaf\u79ef\u5206\u6d4b\u8bd5: \u9640\u87ba(rad/s):%.3f %.3f %.3f\\n', gyr(1), gyr(2), gyr(3));\nfprintf('\u7eaf\u79ef\u5206\u6d4b\u8bd5: \u52a0\u8ba1(m/s^(2)):%.3f %.3f %.3f\\n', acc(1), acc(2), acc(3));\n\nfprintf('\u89e3\u7b97:%d\u6b21 \u603b\u65f6\u95f4:%.3fs\\n', N, N /Fs);\nfprintf('\u6700\u7ec8\u8bef\u5dee(m): %.3f %.3f %.3f\\n', h_pos(end, 1), h_pos(end, 2), h_pos(end, 3));\n\n\n", "meta": {"author": "yandld", "repo": "nav_matlab", "sha": "da70cb2083de407409ebe1ec1096a308611cf063", "save_path": "github-repos/MATLAB/yandld-nav_matlab", "path": "github-repos/MATLAB/yandld-nav_matlab/nav_matlab-da70cb2083de407409ebe1ec1096a308611cf063/example/ins_test/example_ins1.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8872045817875225, "lm_q2_score": 0.6757645944891559, "lm_q1q2_score": 0.5995414444405663}} {"text": "function d = Mtv(solver,I,i)\n% forward operator\n%\n% Input\n% I - intensities\n% alpha - scaling factors\n%\n% Output\n% d - result\n%\n \n% extend specimen symmetry\nlss = numProper(solver.SS);\nI_ext = repmat(I.',lss,1)./lss;\n\n% compute Fourier coefficients\nnfsftmex('set_f', solver.nfft_r(i), I_ext);\nnfsftmex('adjoint', solver.nfft_r(i));\nfhat = nfsftmex('get_f_hat_linear', solver.nfft_r(i));\n\n% convolution with kernel function\nfhat = 4*pi*fhat .* solver.A;\n\n% evaluate Fourier series at pole figure points g h_i\nnfsftmex('set_f_hat_linear', solver.nfft_gh(i), fhat);\nnfsftmex('trafo', solver.nfft_gh(i));\nd = real(nfsftmex('get_f', solver.nfft_gh(i)));\nd = reshape(d,length(solver.c),[]) * solver.refl{i}.';\n\nend\n", "meta": {"author": "mtex-toolbox", "repo": "mtex", "sha": "f0ce46a720935e9ae8106ef919340534bca1adcb", "save_path": "github-repos/MATLAB/mtex-toolbox-mtex", "path": "github-repos/MATLAB/mtex-toolbox-mtex/mtex-f0ce46a720935e9ae8106ef919340534bca1adcb/PoleFigureAnalysis/@MLSSolver/Mtv.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8962513786759492, "lm_q2_score": 0.6688802735722128, "lm_q1q2_score": 0.5994848673582418}} {"text": " function proj = ellipsoid_proj(cg, params, varargin)\n%|function proj = ellipsoid_proj(cg, params, varargin)\n%|\n%| Compute set of 2d line-integral projection views of ellipsoid(s).\n%| Works for both parallel-beam and cone-beam geometry.\n%|\n%| in\n%|\tcg\t\t\tct_geom()\n%|\tparams [ne 9]\t\tellipsoid parameters:\n%|\t\t\t[x_center y_center z_center x_radius y_radius z_radius\n%|\t\t\t\txy_angle_degrees z_angle_degrees amplitude]\n%| options\n%|\toversample\t\tover-sampling factor for emulating \"strips\"\n%|\t\t\t\t(to account for finite detector size)\n%|\n%| out\n%|\tproj\t[ns nt na]\tprojection views\n%|\n%| Copyright 2003-10-22, Patty Laskowsky, Nicole Caparanis, Taka Masuda,\n%| and Jeff Fessler, University of Michigan\n\nif nargin == 1 && streq(cg, 'test'), ellipsoid_proj_test, return, end\nif nargin < 2, ir_usage, end\n\narg.oversample = 1;\narg = vararg_pair(arg, varargin);\n\nproj = ellipsoid_proj_do(params, cg.s, cg.t, cg.ar, cg.source_zs, ...\n\t\tcg.dso, cg.dod, cg.dfs, arg.oversample);\n\nend % ellipsoid_proj()\n\n\n% ellipsoid_proj_do()\nfunction proj = ellipsoid_proj_do(params, ss, tt, ...\n\t\tbeta, ... % [radians]\n\t\tsource_zs, dso, dod, dfs, oversample)\n\nif size(params, 2) ~= 9, error '9 parameters per ellipsoid', end\n\nif oversample > 1\n\tds = ss(2) - ss(1);\n\tdt = tt(2) - tt(1);\n\tif any(abs(diff(ss) / ds - 1) > 1e-6) ...\n\t|| any(abs(diff(tt) / dt - 1) > 1e-6)\n\t\terror 'uniform spacing required for oversampling'\n\tend\n\tNo = oversample;\n\t% determine new finer sampling positions\n\tss = outer_sum([-(No-1):2:(No-1)]'/(2*No)*ds, ss(:)'); % [No ns]\n\ttt = outer_sum([-(No-1):2:(No-1)]'/(2*No)*dt, tt(:)'); % [No nt]\n\tproj = ellipsoid_proj_do(params, ss(:), tt(:), beta, source_zs, dso, dod, dfs, 1);\n\tproj = downsample3(proj, [No No 1]);\nreturn\nend\n\n\n% determine equivalent parallel-beam projection coordinates, at beta=0\nns = length(ss);\nnt = length(tt);\n[sss ttt] = ndgrid(ss, tt);\n\nif isinf(dso) % parallel beam\n\tuu = sss;\n\tvv = ttt;\n\tazim0 = 0;\n\tpolar = 0;\n\nelseif isinf(dfs) % cone-beam with flat detector\n\t[uu vv azim0 polar] = ir_coord_cb_flat_to_par(sss, ttt, dso, dod);\n\nelseif dfs == 0 % cone-beam with arc detector\n\t[uu vv azim0 polar] = ir_coord_cb_arc_to_par(sss, ttt, dso, dod);\n\nelse\n\tfail 'not done'\nend\n\nclear sss ttt\n\ncpolar = cos(polar);\nspolar = sin(polar);\nproj = zeros(ns, nt, numel(beta));\n\n% loop over ellipsoids\nfor ip = 1:size(params,1)\n\tpar = params(ip,:);\n\n\tcx = par(1);\trx = par(4);\n\tcy = par(2);\try = par(5);\n\tcz = par(3);\trz = par(6);\n\txang = deg2rad(par(7)); % xy-plane rotation\n\tzang = deg2rad(par(8)); % z-plane rotation\n\tif zang, error 'z rotation not done', end\n\tval = par(9);\n\n\tfor ib = 1:length(beta)\n%\t\taz = beta(ib) + azim0 - xang; % assume source rotate in xy plane\n\t\taz = beta(ib) + azim0; % correction due to Lei Zhu of Stanford\n\n\t\t% shift property of 3D transform:\n\t\tcz_eff = cz - source_zs(ib); % center relative to source\n\t\tushift = cx * cos(az) + cy * sin(az);\n\t\tvshift = (cx * sin(az) - cy * cos(az)) .* spolar + cz_eff * cpolar;\n\n\t\taz = az - xang; % correction due to Lei Zhu of Stanford\n\t\tp1 = (uu-ushift) .* cos(az) + (vv-vshift) .* sin(az) .* spolar;\n\t\tp2 = (uu-ushift) .* sin(az) - (vv-vshift) .* cos(az) .* spolar;\n\t\tp3 = (vv-vshift) .* cpolar;\n\n\t\te1 = -sin(az) .* cpolar;\n\t\te2 = cos(az) .* cpolar;\n\t\te3 = spolar;\n\n\t\tA = e1.^2 / rx^2 + e2.^2 / ry^2 + e3.^2 / rz^2;\n\t\tB = p1 .* e1 / rx^2 + p2 .* e2 / ry^2 + p3 .* e3 / rz^2;\n\t\tC = p1.^2 / rx^2 + p2.^2 / ry^2 + p3.^2 / rz^2 - 1;\n\n\t\tproj(:,:,ib) = proj(:,:,ib) + 2 * val * sqrt(B.^2 - A.*C) ./ A;\n\tend\nend\n\n% trick: anywhere proj of a single ellipsoid is imaginary, the real part is 0.\nproj = real(proj);\nend % ellipsoid_proj_do()\n\n\n% ellipsoid_proj_test()\nfunction ellipsoid_proj_test\n\nell = [20 0*50 -40 200 100 50 90 0 10;\n 0 50 100 80 80 20 0 0 10];\n\nfun_proj = @(cg) ellipsoid_proj(cg, ell, 'oversample', 2); % analytical\nfun_im = @(ig) ellipsoid_im(ig, ell, 'oversample', 2, 'checkfov', true);\n\nir_proj3_compare1(fun_proj, fun_im, 'chat', 1);\n\nend % ellipsoid_proj_test()\n", "meta": {"author": "JeffFessler", "repo": "mirt", "sha": "b7f36cc46916821e8bc8502301b1554ebc7efe1d", "save_path": "github-repos/MATLAB/JeffFessler-mirt", "path": "github-repos/MATLAB/JeffFessler-mirt/mirt-b7f36cc46916821e8bc8502301b1554ebc7efe1d/fbp/ellipsoid_proj.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933359135361, "lm_q2_score": 0.7310585844894971, "lm_q1q2_score": 0.5993900615853215}} {"text": "% Test file for bndfun/poly.m\n\nfunction pass = test_poly(pref)\n\n% Get preferences.\nif ( nargin < 1 )\n pref = chebfunpref();\nend\n\n% Set the domain\ndom = [-2 7];\n\n%%\n% Check a few simple examples.\n\nf = bndfun(@(x) zeros(size(x)), struct('domain', dom), pref);\np = poly(f);\npass(1) = (norm(p, inf) <= get(f, 'vscale')*eps);\n\nf = bndfun(@(x) 3*ones(size(x)), struct('domain', dom), pref);\np = poly(f);\npass(2) = (norm(p - 3, inf) < get(f, 'vscale')*eps);\n\nf = bndfun(@(x) 6.4*x - 3i, struct('domain', dom), pref);\np = poly(f);\npass(3) = (norm(p - [6.4 (-3i)], inf) < get(f, 'vscale')*eps);\n\nf = bndfun(@(x) 2i*x.^5 - 3.2*x.^4 + 2*x.^2 - (1.2 + 3i), ...\n struct('domain', dom), pref);\np = poly(f);\npass(4) = (norm(p - [2i (-3.2) 0 2 0 -(1.2 + 3i)], inf) ...\n < get(f, 'vscale')*eps);\n\n%%\n% Verify operation for array-valued bndfun objects.\n\nf = bndfun(@(x) [3*ones(size(x)), (6.4*x - 3i), (4*x.^2 - 2i*x + 3.7)], ...\n struct('domain', dom), pref);\np = poly(f);\np_exact = [0 0 3;\n 0 6.4 (-3i);\n 4 (-2i) 3.7];\npass(5) = (norm(p(:) - p_exact(:), inf) < ...\n max(get(f, 'vscale')*eps));\n\nend\n", "meta": {"author": "chebfun", "repo": "chebfun", "sha": "8c49396a55e46ddd57a1d108c6a8f32e37536d54", "save_path": "github-repos/MATLAB/chebfun-chebfun", "path": "github-repos/MATLAB/chebfun-chebfun/chebfun-8c49396a55e46ddd57a1d108c6a8f32e37536d54/tests/bndfun/test_poly.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.819893353516963, "lm_q2_score": 0.7310585669110202, "lm_q1q2_score": 0.5993900600419815}} {"text": "function [RET, REL, RETREL, ndx] = LMprecisionRecall(retrievedBoundingBox, annotation, objectname, mindetectablesize)\n% This function returns one point in the precision-recall curve.\n% Provided a set of detected bounding boxes, it indicates how may objects\n% have been detected (RETREL).\n%\n% The standard measures for IR are recall and precision. Assuming that:\n%\n% * RET is the set of all items the system has retrieved for a specific inquiry;\n% * REL is the set of relevant items for a specific inquiry;\n% * RETREL is the set of the retrieved relevant items \n%\n% then precision and recall measures are obtained as follows:\n%\n% precision = RETREL / RET\n% recall = RETREL / REL \n\n\n% Search the target object in the annotation\nj = LMobjectindex(annotation, objectname);\n\n% Do not consider deleted objects:\nj = j(find(strcmp({annotation.object(j).deleted}, '0')));\n\nNinstances = length(j);\n\n% Extract the bounding boxes for each target present in the image\nBoundingBox = []; REL = 0;\nfor i = 1:Ninstances\n [X,Y] = getLMpolygon(annotation.object(j(i)).polygon);\n BoundingBox = [BoundingBox; min(X) max(X) min(Y) max(Y)];\n \n % If we detect an object that we thought was too small, we should not\n % penalize performance for this. So, we will consider that the only\n % relevant targets are the ones with a size larger than the minimal\n % detectable size. \n if max(Y)-min(Y)>mindetectablesize(1) & max(X)-min(X)>mindetectablesize(2) & max(Y)>0 & max(X)>0\n REL = REL + 1;\n end\nend\n\nRET = size(retrievedBoundingBox, 1);\n\nif REL == 0 \n RETREL = 0;\n return\nend\n\ncxO = mean(BoundingBox(:,1:2),2);\ncyO = mean(BoundingBox(:,3:4),2);\nDxO = diff(BoundingBox(:,1:2),1,2);\nDyO = diff(BoundingBox(:,3:4),1,2);\n\ncxR = mean(retrievedBoundingBox(:,1:2),2);\ncyR = mean(retrievedBoundingBox(:,3:4),2);\nDxR = diff(retrievedBoundingBox(:,1:2),1,2);\nDyR = diff(retrievedBoundingBox(:,3:4),1,2);\n\nndx = [];\nfor i = 1:RET\n d = sqrt(((cxR(i) - cxO)./DxO).^2 + ((cyR(i) - cyO)./DyO).^2)<.5 ...\n & max(DxO/DxR(i), DxR(i)./DxO)<1.5 ...\n & max(DyO/DyR(i), DyR(i)./DyO)<1.5;\n n = find(d);\n if length(n)>0\n ndx(i) = n(1);\n else\n ndx(i) = 0;\n end\nend\nRETREL = sum(unique(ndx)>0); % each object can be detected only once\n\n% If we detect an object that we thought was too small, we should not\n% penalize performance for this. So, if we detected one object that was not\n% considered before within the relevan set, then we will move it into the\n% relevant set:\nREL = max(REL, RETREL);\n\n\n\n", "meta": {"author": "CSAILVision", "repo": "LabelMeToolbox", "sha": "b8eb2179723d8c15a4331c1ea6da5c6cd64e75e2", "save_path": "github-repos/MATLAB/CSAILVision-LabelMeToolbox", "path": "github-repos/MATLAB/CSAILVision-LabelMeToolbox/LabelMeToolbox-b8eb2179723d8c15a4331c1ea6da5c6cd64e75e2/objectdetection/LMprecisionRecall.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933447152497, "lm_q2_score": 0.7310585727705126, "lm_q1q2_score": 0.5993900584115723}} {"text": "%% rigidTransformationMatrixDirect\n% Below is a demonstration of the features of the |rigidTransformationMatrixDirect| function\n\n%%\nclear; close all; clc;\n\n%% Syntax\n% |[M]=rigidTransformationMatrixDirect(V1,V2);|\n\n%% Description\n% This function computes the rigid transformation matrix (translation, and\n% rotation). For the two point matches input sets V1 and V2. \n\n%% Examples\n\n%%\n% Plot settings\nfontSize=15;\nfaceAlpha=1;\nedgeColor='k';\n\n%% Example: \n\n%% Determine the rigid transformation to overlay two surfaces\n% Below is a demonstration of the features of the |rigidTransformationMatrixDirect| function\n \n% Load example patch data\n[F,Vd]=parasaurolophus;\n \n%Translation\nOR=[-1 2 -3]; %Translations\nT = [1 0 0 OR(1);...\n 0 1 0 OR(2);...\n 0 0 1 OR(3);...\n 0 0 0 1]; \n%Rotation\na=[-0.25*pi 0.75*pi 0.1*pi]; %Euler angles\nR = eye(4,4); R(1:3,1:3)=euler2DCM(a);\n\n%Scaling \nv=[2 3 1]; %Scaling factors\nS = [v(1) 0 0 0;...\n 0 v(2) 0 0;...\n 0 0 v(3) 0;...\n 0 0 0 1];\n \nM_true = T * R; %The true transformation matrix\n\n%Point set 1\nV1=Vd+0.5;\n\n%Point set 2 \nV2=tform(M_true,V1);\n\n%%\n% Plotting input data\n\nhf=cFigure;\ntitle('The untransformed surfaces','FontSize',fontSize);\nxlabel('X','FontSize',fontSize); ylabel('Y','FontSize',fontSize); zlabel('Z','FontSize',fontSize);\n\nhp=patch('Faces',F,'Vertices',V1,'FaceColor','g','FaceAlpha',faceAlpha);\n\nhp=patch('Faces',F,'Vertices',V2,'FaceColor','r','FaceAlpha',faceAlpha,'edgeColor',edgeColor);\n\ncamlight headlight;\nset(gca,'FontSize',fontSize);\nview(3); axis tight; axis equal; box on; \ndrawnow; \n\n%% \n% Get the transformation matrix for the point matched data using |rigidTransformationMatrixDirect|\n\n[M_fit]=rigidTransformationMatrixDirect(V1,V2);\n\nV1f=tform((M_fit),V1);\n\n%%\n% Plotting results\n\nhf=cFigure;\ntitle('The green surfaces transformed towards the red','FontSize',fontSize);\nxlabel('X','FontSize',fontSize); ylabel('Y','FontSize',fontSize); zlabel('Z','FontSize',fontSize);\n\nhp=patch('Faces',F,'Vertices',V2,'FaceColor','r','FaceAlpha',0.5,'edgeColor',edgeColor);\n\nhp=patch('Faces',F,'Vertices',V1f,'FaceColor','none','FaceAlpha',0.5,'edgeColor','g');\n% hp=patch('Faces',F,'Vertices',V2ff,'FaceColor','none','FaceAlpha',0.5*2,'edgeColor','b');\n\nset(gca,'FontSize',fontSize);\nview(3); axis tight; axis equal; box on; \ndrawnow; \n\n%% \n%\n% <>\n% \n% _*GIBBON*_ \n% \n% \n% _Kevin Mattheus Moerman_, \n \n%% \n% _*GIBBON footer text*_ \n% \n% License: \n% \n% GIBBON: The Geometry and Image-based Bioengineering add-On. A toolbox for\n% image segmentation, image-based modeling, meshing, and finite element\n% analysis.\n% \n% Copyright (C) 2006-2022 Kevin Mattheus Moerman and the GIBBON contributors\n% \n% This program is free software: you can redistribute it and/or modify\n% it under the terms of the GNU General Public License as published by\n% the Free Software Foundation, either version 3 of the License, or\n% (at your option) any later version.\n% \n% This program is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU General Public License for more details.\n% \n% You should have received a copy of the GNU General Public License\n% along with this program. If not, see .\n", "meta": {"author": "gibbonCode", "repo": "GIBBON", "sha": "8178520664a6148db939eaea87e75b3cba4f2b4f", "save_path": "github-repos/MATLAB/gibbonCode-GIBBON", "path": "github-repos/MATLAB/gibbonCode-GIBBON/GIBBON-8178520664a6148db939eaea87e75b3cba4f2b4f/docs/HELP_rigidTransformationMatrixDirect.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933271118221, "lm_q2_score": 0.7310585669110203, "lm_q1q2_score": 0.5993900407382771}} {"text": "function sump=sum(p,dim)\n% sympoly/sum: sum a sympoly array along a given dimension\n% usage: sump=sum(p);\n% usage: sump=sum(p,dim);\n% \n% arguments:\n% p - sympoly array object\n% dim - (OPTIONAL) dimension to sum over\n% DEFAULT ==1, unless sp is a row vector\n%\n% sump - sympoly object containing the sum reduced array\n\ns = size(p);\nnp = length(s);\n\n% default for dim is 1, UNLESS p is a row vector.\nif (nargin<2) || isempty(dim)\n if (s(1) == 1) && (np==2)\n % a row vector\n dim = 2;\n else\n % any other shape array\n dim = 1;\n end\nend\n\n% for dim == 1 or dim == 2, do the sum using a dot product\nif (dim == 1) && (np == 2)\n % sum down rows\n sump = ones(1,s(1))*p;\n \nelseif (dim == 2) && (np == 2)\n % sum across columns\n sump = p*ones(s(2),1);\n\nelse\n % its an n-d array\n ss = s;\n ss(dim) = 1;\n \n si = cell(1,np);\n for i = 1:np\n si{i} = 1:s(i);\n end\n \n if any(ss~=1)\n sump = repmat(sympoly(0),ss);\n else\n sump = sympoly(0);\n end\n for i = 1:s(dim)\n si{dim} = i;\n sump = sump + p(si{:});\n end\n\nend\n\n\n\n", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/9577-symbolic-polynomial-manipulation/SymbolicPolynomials/@sympoly/sum.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933271118221, "lm_q2_score": 0.7310585669110202, "lm_q1q2_score": 0.599390040738277}} {"text": "function [w, infos] = cd_lasso_elasticnet(problem, options)\n% Coordinate descent algorithm for LASSO problem.\n%\n% Inputs:\n% problem function (cost/grad/hess)\n% options options\n% Output:\n% w solution of w\n% infos information\n%\n% This file is part of GDLibrary and SGDLibrary.\n%\n% Created by H.Kasai on Apr. 18, 2017\n\n\n % set dimensions and samples\n d = problem.dim();\n n = problem.samples(); \n A = problem.A();\n\n % extract options\n if ~isfield(options, 'tol_optgap')\n tol_optgap = 1.0e-12;\n else\n tol_optgap = options.tol_optgap;\n end \n \n if ~isfield(options, 'tol_gnorm')\n tol_gnorm = 1.0e-12;\n else\n tol_gnorm = options.tol_gnorm;\n end \n \n if ~isfield(options, 'max_iter')\n max_iter = 100;\n else\n max_iter = options.max_iter;\n end \n \n if ~isfield(options, 'verbose')\n verbose = false;\n else\n verbose = options.verbose;\n end \n \n if ~isfield(options, 'w_init')\n w = randn(d,1);\n else\n w = options.w_init;\n end \n \n if ~isfield(options, 'f_opt')\n f_opt = -Inf;\n else\n f_opt = options.f_opt;\n end \n \n if ~isfield(options, 'store_w')\n store_w = false;\n else\n store_w = options.store_w;\n end \n \n if ~isfield(options, 'sub_mode')\n sub_mode = 'lasso';\n else\n sub_mode = options.sub_mode;\n end \n \n % initialise\n iter = 0;\n if strcmp(sub_mode, 'lasso')\n AtA = problem.AtA();\n squred_norm_col = diag(AtA);\n else\n AtA_l2 = problem.AtA_l2();\n squred_norm_col = diag(AtA_l2);\n end\n prox_th = ones(d, 1)./squred_norm_col;\n \n % store first infos\n clear infos;\n infos.iter = iter;\n infos.time = 0; \n infos.grad_calc_count = 0; \n f_val = problem.cost(w);\n infos.cost = f_val; \n optgap = f_val - f_opt;\n infos.optgap = optgap;\n grad = problem.full_grad(w);\n gnorm = norm(grad);\n infos.gnorm = gnorm;\n if ismethod(problem, 'reg')\n infos.reg = problem.reg(w); \n end \n if store_w\n infos.w = w; \n end\n \n % set start time\n start_time = tic(); \n \n % print info\n if verbose\n fprintf('CD (%s): Iter = %03d, cost = %.24e, gnorm = %.4e, optgap = %.4e\\n', sub_mode, iter, f_val, gnorm, optgap);\n end \n\n % main loop\n while (optgap > tol_optgap) && (gnorm > tol_gnorm) && (iter < max_iter) \n\n % update i-th coordinate\n if strcmp(sub_mode, 'lasso')\n for i = 1:d \n w_except_i = w;\n w_except_i(i) = 0;\n residual = problem.residual(w_except_i);\n\n snc = squred_norm_col(i);\n w(i) = problem.prox(A(:, i)'*residual/snc, prox_th(i));\n end\n else\n for i = 1:d \n w_except_i = w;\n w_except_i(i) = 0;\n residual = problem.residual(w_except_i, i);\n\n snc = squred_norm_col(i);\n w(i) = problem.prox(residual/snc, prox_th(i));\n end \n \n end\n \n % calculate gradient\n grad = problem.full_grad(w);\n\n % update iter \n iter = iter + 1;\n % calculate error\n f_val = problem.cost(w);\n optgap = f_val - f_opt; \n % calculate norm of gradient\n gnorm = norm(grad);\n \n % measure elapsed time\n elapsed_time = toc(start_time); \n\n % store infoa\n infos.iter = [infos.iter iter];\n infos.time = [infos.time elapsed_time]; \n infos.grad_calc_count = [infos.grad_calc_count iter*n]; \n infos.optgap = [infos.optgap optgap]; \n infos.cost = [infos.cost f_val];\n infos.gnorm = [infos.gnorm gnorm]; \n if ismethod(problem, 'reg')\n reg = problem.reg(w);\n infos.reg = [infos.reg reg];\n end \n if store_w\n infos.w = [infos.w w]; \n end \n \n % print info\n if verbose\n fprintf('CD (%s): Iter = %03d, cost = %.24e, gnorm = %.4e, optgap = %.4e\\n', sub_mode, iter, f_val, gnorm, optgap);\n end \n end\n \n if gnorm < tol_gnorm\n fprintf('Gradient norm tolerance reached: tol_gnorm = %g\\n', tol_gnorm);\n elseif optgap < tol_optgap\n fprintf('Optimality gap tolerance reached: tol_optgap = %g\\n', tol_optgap); \n elseif iter == max_iter\n fprintf('Max iter reached: max_iter = %g\\n', max_iter);\n end \n \nend\n", "meta": {"author": "hiroyuki-kasai", "repo": "SGDLibrary", "sha": "d19a12559c79c3726683243885b15f982f4bec3d", "save_path": "github-repos/MATLAB/hiroyuki-kasai-SGDLibrary", "path": "github-repos/MATLAB/hiroyuki-kasai-SGDLibrary/SGDLibrary-d19a12559c79c3726683243885b15f982f4bec3d/gd_solver/cd_lasso_elasticnet.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8198933183101078, "lm_q2_score": 0.7310585669110202, "lm_q1q2_score": 0.5993900343037084}} {"text": "%UMFPACK_SIMPLE a simple demo\n%\n% Example:\n% umfpack_simple\n%\n% Copyright 1995-2007 by Timothy A. Davis.\n%\n% UMFPACK License:\n%\n% Your use or distribution of UMFPACK or any modified version of\n% UMFPACK implies that you agree to this License. UMFPACK is\n% is free software; you can redistribute it and/or\n% modify it under the terms of the GNU General Public\n% License as published by the Free Software Foundation; either\n% version 2 of the License, or (at your option) any later version.\n\n% Availability: http://www.cise.ufl.edu/research/sparse/umfpack\n%\n% See also: umfpack, umfpack2, umfpack_details\n\nhelp umfpack_simple\n\nformat short\n\nA = [\n 2 3 0 0 0\n 3 0 4 0 6\n 0 -1 -3 2 0\n 0 0 1 0 0\n 0 4 2 0 1\n] ;\nfprintf ('A = \\n') ; disp (A) ;\n\nA = sparse (A) ;\n\nb = [8 45 -3 3 19]' ;\nfprintf ('b = \\n') ; disp (b) ;\n\nfprintf ('Solution to Ax=b via UMFPACK:\\n') ;\nfprintf ('x1 = umfpack2 (A, ''\\\\'', b)\\n') ;\n\nx1 = umfpack2 (A, '\\', b) ;\nfprintf ('x1 = \\n') ; disp (x1) ;\n\nfprintf ('Solution to Ax=b via MATLAB:\\n') ;\nfprintf ('x2 = A\\\\b\\n') ;\n\nx2 = A\\b ;\nfprintf ('x2 = \\n') ; disp (x2) ;\n\nfprintf ('norm (x1-x2) should be small: %g\\n', norm (x1-x2)) ;\n\nfprintf ('Type ''umfpack_demo'' for a full demo of UMFPACK\\n') ;\n", "meta": {"author": "fieldtrip", "repo": "fieldtrip", "sha": "c2039be598a02d86b39aae76bfa7aaa720f9801c", "save_path": "github-repos/MATLAB/fieldtrip-fieldtrip", "path": "github-repos/MATLAB/fieldtrip-fieldtrip/fieldtrip-c2039be598a02d86b39aae76bfa7aaa720f9801c/external/dmlt/external/gpstuff/SuiteSparse/UMFPACK/MATLAB/umfpack_simple.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.7879311956428947, "lm_q2_score": 0.7606506635289835, "lm_q1q2_score": 0.5993403867809531}} {"text": "% Chapter 14 - Poincare Maps and Nonautonomous Systems in the Plane.\n% Programs 14a - Solving an initial value problem.\n% Copyright Birkhauser 2013. Stephen Lynch.\n\n% Solve a differential equation (Example 1).\nr=dsolve('Dr=-r^2','r(0)=1');\n\n% List the first eight returns on the segment {y=0, 0.\n%\n% Copyright (C) 2018 MIT & University of Arizona\n% Authors: Ricardo Baptista & Matthias Poloczek\n% E-mails: rsb@mit.edu & poloczek@email.arizona.edu\n%\n\nclear; close all; clc\naddpath(genpath('../algorithms'))\naddpath(genpath('../stat_model'))\naddpath(genpath('../test_problems/IsingModel'))\naddpath(genpath('../tools'))\n\n% Save inputs in struct\ninputs = struct;\ninputs.n_vars = 12;\ninputs.evalBudget = 100;\ninputs.n_init = 20;\ninputs.lambda = 1e-4;\ninputs.estimator = 'horseshoe';\n\n% Generate random 3x3 graphical model\nTheta = rand_ising_grid(9);\nMoments = ising_model_moments(Theta);\n\n% Save objective function and regularization term\ninputs.model = @(x) KL_divergence_ising(Theta, Moments, x);\ninputs.penalty = @(x) inputs.lambda*sum(x,2);\n\n% Generate initial samples for statistical models\ninputs.x_vals = sample_models(inputs.n_init, inputs.n_vars);\ninputs.y_vals = inputs.model(inputs.x_vals);\n\n% Run BOCS-SDP and BOCS-SA (order 2)\nB_SA = BOCS(inputs.model, inputs.penalty, inputs, 2, 'SA');\nB_SDP = BOCS(inputs.model, inputs.penalty, inputs, 2, 'sdp');\n\n% Plot results\nfigure\nhold on\nplot(1:length(B_SA.objVals), cummin(B_SA.objVals), '-r');\nplot(1:length(B_SDP.objVals), cummin(B_SDP.objVals), '-.b');\nset(gca,'YScale','log')\nxlabel('$t$','interpreter','latex')\nylabel('Best $f(x)$','interpreter','latex')\nlegend({'BOCS - SA','BOCS - SDP'},'location','northeast')\nhold off\n", "meta": {"author": "baptistar", "repo": "BOCS", "sha": "fef0d4e34e376e8bb0dae9955d70c2155530b9eb", "save_path": "github-repos/MATLAB/baptistar-BOCS", "path": "github-repos/MATLAB/baptistar-BOCS/BOCS-fef0d4e34e376e8bb0dae9955d70c2155530b9eb/scripts/example_ising.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278602705731, "lm_q2_score": 0.6791787056691697, "lm_q1q2_score": 0.5993262119849828}} {"text": "function [F] = mci_ramsay_fx (x,U,P,M)\n% State equation for Ramsay model\n% FORMAT [F] = mci_ramsay_fx (x,U,P,M)\n%\n% x State vector\n% x(1) Voltage variable\n% x(2) Recovery variable\n% U inputs\n% P vector of model parameters - 2 params only\n% M model\n%\n% F dx/dt\n%\n% J Ramsay et al (2007) Parameter estimation for differential equations:\n% a generalised smoothing approach. J Roy Stat Soc B, 69(5):741-796.\n%\n% See also section 10 (page 26) and contribution by W.Penny on page 75 of: \n%\n% Girolami and Calderhead (2011) Riemann manifold Langevin and Hamiltonian\n% Monte Carlo methods. J Roy Stat Soc B,73(2):123-214.\n%__________________________________________________________________________\n% Copyright (C) 2015 Wellcome Trust Centre for Neuroimaging\n\n% Will Penny \n% $Id: mci_ramsay_fx.m 6548 2015-09-11 12:39:47Z will $\n\nc=3;\n\nP(1)=exp(P(1));\nP(2)=exp(P(2));\n\nF=zeros(2,1);\nF(1)=c*(x(1)-(1/3)*x(1)^3+x(2));\nF(2)=-(1/c)*(x(1)-P(1)+P(2)*x(2));\n\n", "meta": {"author": "spm", "repo": "spm12", "sha": "3085dac00ac804adb190a7e82c6ef11866c8af02", "save_path": "github-repos/MATLAB/spm-spm12", "path": "github-repos/MATLAB/spm-spm12/spm12-3085dac00ac804adb190a7e82c6ef11866c8af02/toolbox/mci/models/ramsay/mci_ramsay_fx.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8824278664544911, "lm_q2_score": 0.679178699175393, "lm_q1q2_score": 0.5993262104546787}} {"text": "function [mxc,mlat,OUT] = xc_stats(xc,xl,varargin)\n% [mxc,mlat,OUT] = xc_stats(xc,xl,varargin)\n% calculate t-statistic values for a k x k x n 3-D matrix of \n% correlation (xc) and latency (xl) values across n subjects.\n%\n% tor wager\n\n\nnames = [];\nif length(varargin) > 0, names = varargin{1};,end\n\n if isempty(xl), mlat = [];, end\n\n% ------------------------------------------------------------\n% stats on correlation values\n% ------------------------------------------------------------\n\nwarning off, clear stelatency, clear tlat, clear stecorr, clear tcorr\n% standard errors and t-values, element by element\n\n% only do this on the upper triangle, to be faster\n\nfor j = 1:size(xc,2)-1\n for k = j + 1 : size(xc,2)\n \n if ~isempty(xl)\n tmp = squeeze(xl(j,k,:));\n z = tmp; \n [stelatency(j,k),tlat(j,k)] = ste(z); % t-test on latencies; maybe should be poisson dist?\n end\n \n tmp = squeeze(xc(j,k,:));\n z = .5 * log( (1+tmp) ./ (1-tmp) ); % Fisher's r-to-z transform\n [stecorr(j,k),tcorr(j,k)] = ste(z); % correl in rand fx analysis across ss\n end\nend\nwarning on\n\n\n% makes symmetric matrices from upper tri\n\nif ~isempty(xl), stelatency(end+1,:) = 0; ,end\nstecorr(end+1,:) = 0;\ntcorr(end+1,:) = 0; \nif ~isempty(xl), \n tlat(end+1,:) = 0; \n stelatency = stelatency + stelatency';\nend\n\nstecorr = stecorr + stecorr' + Inf * eye(size(stecorr,1));\ntcorr = tcorr + tcorr'; % t-scores for significance/reliability of cross-correlations across subjects\n\nif ~isempty(xl)\n tlat = tlat + tlat'; % same for time lags across subjects\nend\n\n% group means\n\nif ~isempty(xl)\n mlat = mean(xl,3); % mean of latency data (cross-lag, group average)\nend\nmxc = mean(xc,3); % mean cross-correlations among k regions, group average\n\n\n% ------------------------------------------------------------\n% print and save output\n% ------------------------------------------------------------\n\n\nOUT.desc1 = 'xl is latency mtx for each subject, xc is individual correlation mtx';\nif ~isempty(xl), OUT.xl = xl;, end\nOUT.xc = xc;\nOUT.desc2 = 'mlat and mxc: matrices of means across subjects for latency and correl'\nOUT.desc3 = 'tlat/tcorr are t-values across z-transformed correlations';\nOUT.mxc = mxc;\n\nif ~isempty(xl)\n OUT.mlat = mlat;\n OUT.tlat = tlat;\n OUT.tcorr = tcorr;\nend\n\n% Output\nif ~isempty(xl)\n fprintf(1,'Latency\\n');\n str = correlation_to_text(mlat,Inf,names);\nend\n\nfprintf(1,'correlation T-values, p<.05 corrected, assuming normal distribution of latency diffs\\n');\n% Alpha correction - bonferroni.\nnumobs=(size(mxc,1)*(size(mxc,1)-1))/2;\ncorrp=1-(0.05/ (2 * ( numobs ))); % 2-tailed corr p\ncrit_t = tinv_t(corrp,size(xc,1)-3); % critical t-value for corrected significance\ncrit_tu = tinv_t(1-(.05/2),size(xc,1)-3); % critical t-value for uncorrected significance\n\nif ~isempty(xl)\n str = correlation_to_text(tlat,crit_t,names);\nend\n\nOUT.crit_t = crit_t;\nOUT.crit_tu = crit_tu;\nOUT.crit_tdesc = 'crit_t crit t value corrected, _tu uncorrected';\nOUT.corrp = corrp;\nOUT.corrpdesc = 'critical corrected p-value (bonferroni)';\n\n\nfprintf(1,'Average correlation across subjects\\n');\n[str, sigu] = correlation_to_text(mxc,Inf,names);\n\nfprintf(1,'Corr T-values, p<.05 uncorrected, 2-tailed, assuming independent samples over time\\n');\n[str, sigu] = correlation_to_text(tcorr,crit_tu,names);\nOUT.sigmat_uncorrected = sigu;\n\nfprintf(1,'Corr T-values, p<.05 corrected, 2-tailed, assuming independent samples over time\\n');\n[str, sigmat] = correlation_to_text(tcorr,crit_t,names);\n\nOUT.sigmat = sigmat;\n\n\n\n\nreturn", "meta": {"author": "canlab", "repo": "CanlabCore", "sha": "af242e120f0480c4feaeea90471c015a14f1f60e", "save_path": "github-repos/MATLAB/canlab-CanlabCore", "path": "github-repos/MATLAB/canlab-CanlabCore/CanlabCore-af242e120f0480c4feaeea90471c015a14f1f60e/CanlabCore/Statistics_tools/Support_functions/xc_stats.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8824278633625322, "lm_q2_score": 0.679178699175393, "lm_q1q2_score": 0.5993262083546861}} {"text": "function t=getDCTTransform(im,N)\ns=dctmtx(N);\nt=s*im*s';", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/41333-simulation-of-dct-walsh-hadamard-haar-and-slant-transform-using-variable-block-sizes/getDCTTransform.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9407897442783526, "lm_q2_score": 0.6370308013713525, "lm_q1q2_score": 0.5993120447195888}} {"text": "function gIX = KmeansSubdivide(numK2,gIX,M_0)\ngIX_old = gIX;\nU = unique(gIX);\n for i = 1:length(U),\n IX = find(gIX_old == U(i));\n M_sub = M_0(IX,:);\n \n if numK2= 1\n\tif (size(W{i}, 2) == size(resp{i-1}, 1) + 1)\n\t grad{i} = backward{i} * [resp{i-1}(:,nonzero_grad)' ones(snonzero_grad, 1)];\n\telse\n\t grad{i} = backward{i} * resp{i-1}(:,nonzero_grad)';\n\tend \n else\n\tgrad{i} = backward{i} * X(:, nonzero_grad)';\n end\n end\n else\n for i=nlayer:-1:1\n if (i == nlayer)\n\ttmp = hout;\n else\n\ttmp = (W{i+1}' * backward{i+1});\n end\n \n if (size(tmp, 1) ~= size(resp{i}, 1))\n\ttmp = tmp(1:end-1, :);\n end\n \n backward{i} = tmp .* (1 - resp{i}.^2);\n \n if (i-1) >= 1\n\tif (size(W{i}, 2) == size(resp{i-1}, 1) + 1)\n\t grad{i} = backward{i} * [resp{i-1}' onesncases];\n\telse\n\t grad{i} = backward{i} * resp{i-1}';\n\tend\n else\n\tgrad{i} = backward{i} * X';\n end\n end\n end\n \nelseif (nonlinearity == 2)\n\n if (exist('nonzero_grad', 'var'))\n snonzero_grad = sum(nonzero_grad);\n if (snonzero_grad == 0)\n for i=nlayer:-1:1\n\tgrad{i} = zeros(size(W{i}));\n end\n return;\n end\n \n for i=nlayer:-1:1\n if (i == nlayer)\n\ttmp = hout(:, nonzero_grad);\n else\n\ttmp = (W{i+1}' * backward{i+1});\n end\n \n if (size(tmp, 1) ~= size(resp{i}, 1))\n\ttmp = tmp(1:end-1, :);\n end\n \n backward{i} = tmp .* (1 - resp{i}(:,nonzero_grad)) .* resp{i}(:,nonzero_grad);\n \n if (i-1) >= 1\n\tif (size(W{i}, 2) == size(resp{i-1}, 1) + 1)\n\t grad{i} = backward{i} * [resp{i-1}(:,nonzero_grad)' gones(snonzero_grad,1,gputype)];\n\telse\n\t grad{i} = backward{i} * resp{i-1}(:,nonzero_grad)';\n\tend\n else\n\tgrad{i} = backward{i} * X(:, nonzero_grad)';\n end\n end\n else\n for i=nlayer:-1:1\n if (i == nlayer)\n\ttmp = hout;\n else\n\ttmp = (W{i+1}' * backward{i+1});\n end\n \n if (size(tmp, 1) ~= size(resp{i}, 1))\n\ttmp = tmp(1:end-1, :);\n end\n \n backward{i} = tmp .* (1 - resp{i}) .* resp{i};\n \n if (i-1) >= 1\n\tif (size(W{i}, 2) == size(resp{i-1}, 1) + 1)\n\t grad{i} = backward{i} * [resp{i-1}' onesncases];\n\telse\n\t grad{i} = backward{i} * resp{i-1}';\n\tend\n else\n\tgrad{i} = backward{i} * X';\n end\n end\n end\n \nelseif (nonlinearity == 3)\n \n if (exist('nonzero_grad', 'var'))\n snonzero_grad = sum(nonzero_grad);\n if (snonzero_grad == 0)\n for i=nlayer:-1:1\n\tgrad{i} = zeros(size(W{i}));\n end\n return;\n end\n \n for i=nlayer:-1:1\n if (i == nlayer)\n\ttmp = hout(:, nonzero_grad);\n else\n\ttmp = (W{i+1}' * backward{i+1});\n end\n \n if (size(tmp, 1) ~= size(resp{i}, 1))\n\ttmp = tmp(1:end-1, :);\n end\n \n if (i == nlayer)\n\tbackward{i} = tmp .* (1 - resp{i}(:,nonzero_grad)^2);\n else\n\tbackward{i} = tmp .* (1 - resp{i}(:,nonzero_grad)) .* resp{i}(:,nonzero_grad);\n end\n \n if (i-1) >= 1\n\tif (size(W{i}, 2) == size(resp{i-1}, 1) + 1)\n\t grad{i} = backward{i} * [resp{i-1}(:,nonzero_grad)' gones(snonzero_grad,1,gputype)];\n\telse\n\t grad{i} = backward{i} * resp{i-1}(:,nonzero_grad)';\n\tend\n else\n\tgrad{i} = backward{i} * X(:, nonzero_grad)';\n end\n end\n else\n for i=nlayer:-1:1\n if (i == nlayer)\n\ttmp = hout;\n else\n\ttmp = (W{i+1}' * backward{i+1});\n end\n \n if (size(tmp, 1) ~= size(resp{i}, 1))\n\ttmp = tmp(1:end-1, :);\n end\n \n if (i == nlayer)\n\tbackward{i} = tmp .* (1 - resp{i}.^2);\n else\n\tbackward{i} = tmp .* (1 - resp{i}) .* resp{i};\n end\n\n if (i-1) >= 1\n\tif (size(W{i}, 2) == size(resp{i-1}, 1) + 1)\n\t grad{i} = backward{i} * [resp{i-1}' onesncases];\n\telse\n\t grad{i} = backward{i} * resp{i-1}';\n\tend\n else\n\tgrad{i} = backward{i} * X';\n end\n end\n end\n\nend\n", "meta": {"author": "norouzi", "repo": "hdml", "sha": "78e01180fc2494db31f04a9f4653456a8bfb8ba0", "save_path": "github-repos/MATLAB/norouzi-hdml", "path": "github-repos/MATLAB/norouzi-hdml/hdml-78e01180fc2494db31f04a9f4653456a8bfb8ba0/compute_NN_grad.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8652240756264639, "lm_q2_score": 0.6926419831347361, "lm_q1q2_score": 0.5992905195978329}} {"text": "function s=sprintsi(x,d,w)\n%SPRINTSI Print X with SI multiplier S=(X,D,W)\n% D is number of decimal places (+ve) or significant digits (-ve) [default=-3]\n% |W| is total width including multiplier\n% if W<=0 then trailing 0's will be eliminated\n%\n% Example: sprintsi(2345,-2) gives '2.3 k'\n\n% Copyright (C) Mike Brookes 1998\n% Version: $Id: sprintsi.m 713 2011-10-16 14:45:43Z dmb $\n%\n% VOICEBOX is a MATLAB toolbox for speech processing.\n% Home page: http://www.ee.ic.ac.uk/hp/staff/dmb/voicebox/voicebox.html\n%\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% This program is free software; you can redistribute it and/or modify\n% it under the terms of the GNU General Public License as published by\n% the Free Software Foundation; either version 2 of the License, or\n% (at your option) any later version.\n%\n% This program is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU General Public License for more details.\n%\n% You can obtain a copy of the GNU General Public License from\n% http://www.gnu.org/copyleft/gpl.html or by writing to\n% Free Software Foundation, Inc.,675 Mass Ave, Cambridge, MA 02139, USA.\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\nif nargin<3 w=0; end;\nif nargin<2 d=-3; end;\nf='afpnum kMGT';\ne=max(-18,min(12,floor(log10(abs(x)))));\nk=floor(e/3);\ndp=max([0 d 3*k-d-e-1]);\nif w<=0 & dp\n w=abs(w);\n dp=max(find([1 mod(mod(round(x*10^(dp-3*k)),10^dp),10.^(dp:-1:1))]))-1;\nend\nif(k)\n s=sprintf(sprintf('%%%d.%df %c',w-2,dp,f(k+7)),x*1e-3^k);\nelse\n s=sprintf(sprintf('%%%d.%df ',w-1,dp),x*1e-3^k);\nend\n", "meta": {"author": "covarep", "repo": "covarep", "sha": "5a2be5d6b776f14a0b275c69fde90eb13849e60d", "save_path": "github-repos/MATLAB/covarep-covarep", "path": "github-repos/MATLAB/covarep-covarep/covarep-5a2be5d6b776f14a0b275c69fde90eb13849e60d/external/voicebox/sprintsi.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8031737869342623, "lm_q2_score": 0.7461389986757757, "lm_q1q2_score": 0.5992792851457613}} {"text": "function pass = test_minus( pref ) \n% This tests the basic arithmetic operations on chebfun2 objects.\n\nif ( nargin < 1 ) \n pref = chebfunpref; \nend \ntol = 1e5 * pref.cheb2Prefs.chebfun2eps;\nj = 1;\n\nD = [-1 1 -1 1; -2 2 -2 2; -1 pi 0 2*pi];\n\nfor r = 1 : size(D,1)\n f = chebfun2(@(x,y) cos(x.*y), D(r,:));\n g = chebfun2(@(x,y) x + y + x.*y, D(r,:));\n \n FminusG = chebfun2(@(x,y) cos(x.*y) - (x + y + x.*y), D(r,:) );\n \n tolr = norm(D(r,:),inf)*tol;\n \n pass(j) = ( norm( (f-g) - FminusG ) < 10*tolr ); j = j + 1;\n \nend\n\n\nend", "meta": {"author": "chebfun", "repo": "chebfun", "sha": "8c49396a55e46ddd57a1d108c6a8f32e37536d54", "save_path": "github-repos/MATLAB/chebfun-chebfun", "path": "github-repos/MATLAB/chebfun-chebfun/chebfun-8c49396a55e46ddd57a1d108c6a8f32e37536d54/tests/chebfun2/test_minus.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8031737775116229, "lm_q2_score": 0.7461390043208003, "lm_q1q2_score": 0.5992792826490982}} {"text": "% GP_COV_SUM - Covariance function as a sum of two covariance functions.\n%\n% Usage:\n%\n% COVFUNC = GP_COV_SUM(COVFUNC1, COVFUNC2)\n%\n% The returned covariance function is called as\n%\n% K = COVFUNC(THETA)\n% [K, DK] = COVFUNC(THETA)\n%\n% where THETA is a vector of parameters. The parameters of COVFUNC1 and\n% COVFUNC2 are concatenated into a single parameter vector.\n%\n% If no arguments are given, dimensionality information is returned:\n%\n% [N_THETA, N1, N2] = COVFUNC()\n%\n% N_THETA : Number of non-fixed parameters\n% N1 : Number of rows in the covariance matrix\n% N2 : Number of columns in the covariance matrix\n%\n% See also GP_COV, GP_COV_PRODUCT.\n\n% Last modified 2010-01-25\n% Copyright (c) Jaakko Luttinen (jaakko.luttinen@tkk.fi)\n\nfunction func = gp_cov_sum(varargin)\n\nfunc = @get_covariance;\n\nif nargin < 2\n error('Must give at least two covariance functions')\nend\n\ncovfuncs = varargin ;\n\n% Number of covariance functions\nn_funcs = nargin ;\n\n% Number of parameters for each covariance function\nn_theta = zeros(n_funcs,1) ;\n% Dimensionalities of each covariance function\nM = zeros(n_funcs,1) ;\nN = zeros(n_funcs,1) ;\n% Extract the values from the covariance functions\nfor i = 1:n_funcs\n [n_theta(i), M(i), N(i)] = varargin{i}();\nend\n\n% Indices of the hyperparameters for each covariance function\nind_theta = cell(n_funcs,1);\nfor i = 1:n_funcs\n ind_theta{i} = (1+sum(n_theta(1:(i-1)))):(sum(n_theta(1:i))) ;\nend\n\n%[n_theta1, M1, N1] = covfunc1();\n%[n_theta2, M2, N2] = covfunc2();\n\nif ~all(M == M(1)) || ~all(N == N(1))\n error('Can''t sum covariance matrices with different dimensionalities');\nend\nM = M(1) ;\nN = N(1) ;\n\n function varargout = get_covariance(theta)\n \n if nargout == 0\n nout = 1 ;\n else\n nout = nargout ;\n end\n \n varargout = cell(nout,1);\n\n out = cell(nout,1);\n varargout = cell(nout,1);\n \n % Return only dimension information if requested\n if nargin == 0\n if nout >= 1\n varargout{1} = sum(n_theta); % number of parameters\n if nout >= 2\n varargout{2} = M; % dimensionalities\n if nout >= 3\n varargout{3} = N; % dimensionalities\n end\n end\n end\n return\n end\n\n varargout{1} = 0 ;\n varargout{2} = cell(sum(n_theta),1) ;\n \n for i = 1:n_funcs\n % Compute the covariance matrix\n [out{:}] = covfuncs{i}(theta(ind_theta{i}));\n varargout{1} = varargout{1} + out{1};\n \n % Compute the derivative\n if nout >= 2\n varargout{2}(ind_theta{i}) = out{2}(:);\n end\n end\n \n end\n\nend", "meta": {"author": "jluttine", "repo": "matlab", "sha": "63406c7782b0869948f06e1dbc594460c165d24e", "save_path": "github-repos/MATLAB/jluttine-matlab", "path": "github-repos/MATLAB/jluttine-matlab/matlab-63406c7782b0869948f06e1dbc594460c165d24e/gp/gp_cov_sum.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267118026095992, "lm_q2_score": 0.7248702821204019, "lm_q1q2_score": 0.5992588175898862}} {"text": "function [Xmat,idxisa] = workvolume(cam,room,imres,idxcams)\n\nSTEP = 0.1;\n\nif nargin < 4\n\tidxcams = [1:size(cam,2)];\nend\n\nif nargin < 3\n\timres = repmat([640 480],size(idxcams,2),1);\nend\nimres = imres(idxcams,:);\n\nif nargin < 2\n\t% room [x_min, x_max, y_min, y_max, z_min, z_max]\n\troom = [-3 3 -3 3 0 3];\nend\n\n% compose Pmat containing all P matrices\nPmat = [];\nfor i=idxcams,\n\tPmat = [Pmat; cam(i).P];\nend\n\n% create points\n\nzcoor = room(5):STEP:room(6);\nznum = size(zcoor,2);\nycoor = room(3):STEP:room(4);\nynum = size(ycoor,2);\nxcoor = room(1):STEP:room(2);\nxnum = size(xcoor,2);\n\n\nbuff = repmat(ycoor,znum,1);\nyvec = reshape(buff,prod(size(buff)),1);\nzvec = repmat(zcoor',ynum,1);\n\nbuff = repmat(xcoor,znum*ynum,1);\nxvec = reshape(buff,prod(size(buff)),1);\n\nXmat = [xvec,repmat([yvec,zvec],xnum,1)];\nXmat = [Xmat,ones(size(Xmat(:,1)))];\n\nclear buff\n\nsize(Xmat)\numat = Pmat*Xmat';\n\n% normalize projected points in umat\nscalemat = [];\nfor i=1:size(idxcams,2),\n\tscalemat = [scalemat; repmat(umat(3*i,:),3,1)];\nend\numat = umat./scalemat;\nclear scalemat;\nmask = zeros(size(umat));\nmask(1:3:end,:) = umat(1:3:end,:)0);\nidxisa = find(sum(mask)==size(mask,1));\n\nreturn;\n\n", "meta": {"author": "strawlab", "repo": "MultiCamSelfCal", "sha": "0a26c88c63d8513eab76553033a9a6fb15ba6575", "save_path": "github-repos/MATLAB/strawlab-MultiCamSelfCal", "path": "github-repos/MATLAB/strawlab-MultiCamSelfCal/MultiCamSelfCal-0a26c88c63d8513eab76553033a9a6fb15ba6575/MultiCamValidation/CoreFunctions/workvolume.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267118026095991, "lm_q2_score": 0.7248702821204019, "lm_q1q2_score": 0.5992588175898861}} {"text": "function [beta, t, pvals, convals, con_t, con_pvals, sigma, Phi, df, stebeta, conste, F] = fit_gls(y, X, c, p, varargin)\n% Fit a linear model using generalized least squares and an AR(p) model\n%\n% :Usage:\n% ::\n%\n% [beta, t, pvals, convals, con_t, con_pvals, sigma, Phi, df, stebeta, conste, F] = fit_gls(y,X,c,p,[PX, equal to pinv(X), for speed], [Weights])\n%\n% This program uses the Cochrane-Orcutt algorithm to iteratively find the\n% GLS solution and estimate the noise parameters.\n%\n% Step 1: Find the OLS solution.\n%\n% Step 2: Use residuals from the previous fit to estimate the parameters in\n% the AR(p) noise model.\n%\n% Step 3: Find the GLS solution using the covariance matrix corresponding\n% to an AR(p) model with parameters estimated in Step 2 inserted.\n%\n% Step 4: Repeat steps 2-3 until convergence.\n%\n% :Inputs:\n%\n% **y:**\n% fMRI time course (T x 1 vector)\n%\n% **X:**\n% Design matrix (T x param matrix)\n%\n% **c:**\n% contrast vector(s) (param x # contrasts matrix)\n%\n% **p:**\n% order of AR model.\n%\n% **PX:**\n% pinv(X), for speeded, repeated calculations with different y vectors\n%\n% Note: if using weights, px = inv(X' * W * X) * X' * W; \n% where W = diag(Weights);\n%\n% **Weights:**\n% Optional, vector of weights for each observation\n%\n% Empty or missing: Unweighted analysis.\n%\n% Note that setting p=0 implies a white noise model.\n%\n% :Output:\n%\n% **t:**\n% t-value for the contrast c'beta\n%\n% **df:**\n% degrees of freedom using Satterthwaite approximation\n%\n% **beta:**\n% beta vector\n%\n% **Phi:**\n% vector of coefficients in AR(p) model\n%\n% **sigma:**\n% standard deviation\n%\n% **stebeta:**\n% standard error of betas\n%\n% ..\n% by Martin Lindquist\n%\n% Last updated: 3/29/08, Tor Wager, added weighted least squares\n% verified that beta and t-values are identical to\n% glmfit.m in matlab7.5 with ar p = 0\n% ***AR(p) with weighted least squares needs to be\n% checked. behaving reasonably.\n% 4/1/08, Tor : output stats for boht betas and contrasts\n% Reorganized order of outputs\n% 5/15/08 Tor : Weird things happening with single inputs; particulaly with aryule; force\n% double\n% ..\n\ny = double(y);\nX = double(X);\n\nT = length(y); % Length of time course\n\nk = size(X, 2); % predictors\n\n\nif length(varargin) > 1\n w = double(varargin{2}); % weights for weighted least squares\nelse\n w = ones(T, 1);\nend\nW = diag(w);\nsqrtW = sqrt(W); % for weighted residuals\n\nif ~isempty(varargin) && ~isempty(varargin{1})\n px = double(varargin{1});\nelse\n invxvx = inv(X' * W * X); % we can re-use this later if p == 0\n px = invxvx * X' * W; \nend\n\n\n% Step 1: Find the OLS solution \nbeta = px*y; % Beta values; weighted, if weights are used\nresid = sqrtW * y - sqrtW * X * beta; % Residuals (Weighted, if weights are used)\nsigma = sqrt((1 / (T - k)) * resid' * resid); %sum(resid.^2))); % Estimate of Sigma\n\n% Weighted residuals: Three equivalent ways\n% We pick one that is compatible with AR estimation\n% 1)\n% beta = px*y; % Beta values\n% resid = y - X*beta; % Residuals\n% sigma = sqrt((1 / (T - k)) * resid' * W * resid); %sum(resid.^2))); % Estimate of Sigma\n\n% 2) \n%r2 = sqrt(W) * resid; sigma2 = sqrt((1 / (T - k)) * r2' * r2)\n\n% 3)\n% r2 = sqrt(W) * y - sqrt(W) * X * beta;\n% sigma2 = sqrt((1 / (T - k)) * r2' * r2)\n\n% Stuff needed for future iterations\niV = W; % for ar p = 0 case\nA = W; % for ar p = 0 case\nPhi = 0;\nbetaold = 0;\n\n% Steps 2-4: Find the GLS solution by iteration \n% If p=0, skip this step. Appropriate solution already calculated above.\n% Continue iteration until convergence or for at most 10 loops.\n%\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% Note to Jack and Tor: Keith Worsley uses a similar algorithm when fitting\n% a GLM with an AR(p) noise model. However, he skips the iterative step\n% and only goes through the loop one time. He claims that this is enough. I\n% am not entirely convinced, therefore it is probably better to go through\n% a few times if needed.\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\ni=1; % Set counter\n\nwhile i < 10 && p > 0 && (i == 1 || sum((beta - betaold).^2) > 0.001)\n % Do up to 10 iterations, if arp > 0 and either first iteration or\n % there's a difference from last iteration\n \n % resid = y - X*beta; % Calculate residuals of current model fit\n\n resid = sqrtW * y - sqrtW * X * beta; % Residuals (Weighted, if weights are used)\n\n % Estimate AR parameters using residuals\n [a,e] = aryule(resid, p);\n Phi =zeros(length(a)-1,1);\n Phi(1:p) = -a(2:(p+1));\n\n %sigma = sqrt(e); % swrtW*e?? % Moved later, because never used until\n %after iteration loop\n\n % Find the inverse of the covariance matrix\n A = sqrtW; % ***should be sqrt(W)?\n\n for j=1:p\n %A = A + diag(-Phi(j)*ones((T-j),1),-j);\n\n A = A + sqrtW * diag(-Phi(j)*ones((T-j),1),-j);\n end;\n\n %create_figure('A'); imagesc(A, [-.2 .2]); colorbar, drawnow, input(' ')\n\n iV = A*A'; % New weights, with AR estimates, The inverse of the covariance matrix\n\n\n betaold = beta; % Set old solution to be betaold\n beta = inv(X'*iV*X)*X'*iV*y; % Calculate new solution\n\n i = i+1; % Add one to counter\n\n %create_figure('COV'); imagesc(iV, [-.02 .02]); colorbar, drawnow, input(' ')\nend\n\nif p > 0 \n % re-calc sigma\n sigma = sqrt(e);\n\n invxvx = inv(X'*iV*X);\n \n % Should we use the kind of thing below? Seems like sqrt(e) is unweighted,\n % though it seems reasonable...\n % sqrtiv = sqrt(iV);\n % resid = sqrtiv * y - sqrtiv * X * beta; % Residuals (Weighted, if weights are used)\n % sigma = sqrt((1 / (T - k)) * resid' * resid)\nend\n\n\n\nR = (eye(T) - X * invxvx * X' * iV); % Residual inducing matrix\n\nWd = R * A * inv(iV) * A'; % inv(iV) = Covariance matrix\ndf = (trace(Wd).^2)./trace(Wd*Wd); % Satterthwaite approximation for degrees of freedom\n\n\n% Should check on below: this creates difference in t-values from\n% glmfit...but why wouldn't we need to re-calculate a (larger) sigma if we have reduced df?\n% if df ~= (T - k) % Tor added 3/29, have to re-calculate sigma\n% sigma = sqrt((1 / df) * resid' * iV * resid); %sum(resid.^2))); % Estimate of Sigma\n% end\n\nvarbeta = sigma^2.* invxvx; % Var(beta)\nstebeta = diag(varbeta).^.5;\nt = beta ./ stebeta;\n\nconvals = [];\nconste = [];\ncon_t = [];\ncon_pvals = [];\nF = [];\nif ~isempty(c)\n % Contrast(s)\n convals = (c' * beta);\n conste = diag(c' * varbeta * c).^.5; % tor added as output\n con_t = convals ./ conste; %sqrt(c'*varbeta*c); % t-value\nend\n\n% get rid of nuisance regressors that aren't in any contrast\n% wh = stebeta > 0;\n% c = c(wh,wh); \n% beta = beta(wh);\n% stebeta = stebeta(wh);\n% \n% if ~isempty(c)\n% beta = (c' * beta);\n% %beta = beta(wh);\n% t = beta ./ stebeta; %sqrt(c'*varbeta*c); % t-value\n% else\n% t = beta(wh) ./ stebeta;\n% end\n\n%%%%%% Test H0: beta_1 = beta_2 = .... = beta_param = 0\nif nargout > 6\n SSE = y'*y - beta'*X'*y; % Error sum of squares\n mSSE = SSE/df;\n J = ones(T);\n SST=y'*y - (1/T).*y'*J*y; % Total sum of squares\n SSM=SST-SSE; % Model sum of squares\n\n dfSSM=length(c) - 1; % degrees of freedom for model (param - 1)\n mSSM=SSM/dfSSM;\n\n F=mSSM/mSSE; % F-statistic - compare with F-distruibution with (param-1, df) degrees of freedom\nend\n\n% % get contrast values if we need those\n% if ~isempty(c)\n% beta = (beta' * c)';\n% end\n\nif nargout > 2\n pvals = 2 .* (1 - tcdf(abs(t), df)); % two-tailed\n \n \n % make sure p-values for valid results are not zero...\n pvals(pvals == 0 & beta ~= 0 & ~isnan(beta)) = 1000*eps;\n \n if ~isempty(c) && nargout > 5\n con_pvals = 2 .* (1 - tcdf(abs(con_t), df)); % two-tailed\n \n con_pvals(con_pvals == 0 & convals ~= 0 & ~isnan(convals)) = 1000*eps;\n end\n \nend\n\nreturn\n\n", "meta": {"author": "canlab", "repo": "CanlabCore", "sha": "af242e120f0480c4feaeea90471c015a14f1f60e", "save_path": "github-repos/MATLAB/canlab-CanlabCore", "path": "github-repos/MATLAB/canlab-CanlabCore/CanlabCore-af242e120f0480c4feaeea90471c015a14f1f60e/CanlabCore/Statistics_tools/fit_gls.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267117940706734, "lm_q2_score": 0.7248702880639791, "lm_q1q2_score": 0.599258816313898}} {"text": "function [ quasi, seed_new ] = sobol ( dim_num, seed )\n\n%% SOBOL generates a new quasirandom Sobol vector with each call.\n%\n% Discussion:\n%\n% The routine adapts the ideas of Antonov and Saleev.\n%\n% Modified:\n%\n% 30 March 2003\n%\n% Reference:\n%\n% Antonov and Saleev,\n% USSR Computational Mathematics and Mathematical Physics,\n% Volume 19, 1980, pages 252 - 256.\n%\n% Paul Bratley and Bennett Fox,\n% Algorithm 659:\n% Implementing Sobol's Quasirandom Sequence Generator,\n% ACM Transactions on Mathematical Software,\n% Volume 14, Number 1, pages 88-100, 1988.\n%\n% Bennett Fox,\n% Algorithm 647:\n% Implementation and Relative Efficiency of Quasirandom \n% Sequence Generators,\n% ACM Transactions on Mathematical Software,\n% Volume 12, Number 4, pages 362-376, 1986.\n%\n% I Sobol,\n% USSR Computational Mathematics and Mathematical Physics,\n% Volume 16, pages 236-242, 1977.\n%\n% I Sobol and Levitan, \n% The Production of Points Uniformly Distributed in a Multidimensional \n% Cube (in Russian),\n% Preprint IPM Akad. Nauk SSSR, \n% Number 40, Moscow 1976.\n%\n% Parameters:\n%\n% Input, integer DIM_NUM, the number of spatial dimensions.\n% DIM_NUM must satisfy 2 <= DIM_NUM <= 40.\n%\n% Input/output, integer SEED, the \"seed\" for the sequence.\n% This is essentially the index in the sequence of the quasirandom\n% value to be generated. On output, SEED has been set to the\n% appropriate next value, usually simply SEED+1.\n% If SEED is less than 0 on input, it is treated as though it were 0.\n% An input value of 0 requests the first (0-th) element of the sequence.\n%\n% Output, real QUASI(DIM_NUM), the next quasirandom vector.\n%\n global SOBOL_lastq;\n global SOBOL_seed;\n\n dim_max = 40;\n%\n% Initialize (part of) V.\n%\n v(1:40,1:30) = zeros(40,30);\n\n v(1:40,1) = [ ...\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, ...\n 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 ]';\n\n v(3:40,2) = [ ...\n 1, 3, 1, 3, 1, 3, 3, 1, ...\n 3, 1, 3, 1, 3, 1, 1, 3, 1, 3, ...\n 1, 3, 1, 3, 3, 1, 3, 1, 3, 1, ...\n 3, 1, 1, 3, 1, 3, 1, 3, 1, 3 ]';\n\n v(4:40,3) = [ ...\n 7, 5, 1, 3, 3, 7, 5, ...\n 5, 7, 7, 1, 3, 3, 7, 5, 1, 1, ...\n 5, 3, 3, 1, 7, 5, 1, 3, 3, 7, ...\n 5, 1, 1, 5, 7, 7, 5, 1, 3, 3 ]';\n\n v(6:40,4) = [ ...\n 1, 7, 9,13,11, ...\n 1, 3, 7, 9, 5,13,13,11, 3,15, ...\n 5, 3,15, 7, 9,13, 9, 1,11, 7, ...\n 5,15, 1,15,11, 5, 3, 1, 7, 9 ]';\n \n v(8:40,5) = [ ...\n 9, 3,27, ...\n 15,29,21,23,19,11,25, 7,13,17, ...\n 1,25,29, 3,31,11, 5,23,27,19, ...\n 21, 5, 1,17,13, 7,15, 9,31, 9 ]';\n\n v(14:40,6) = [ ...\n 37,33, 7, 5,11,39,63, ...\n 27,17,15,23,29, 3,21,13,31,25, ...\n 9,49,33,19,29,11,19,27,15,25 ]';\n\n v(20:40,7) = [ ...\n 13, ...\n 33,115, 41, 79, 17, 29,119, 75, 73,105, ...\n 7, 59, 65, 21, 3,113, 61, 89, 45,107 ]';\n\n v(38:40,8) = [ ...\n 7, 23, 39 ]';\n%\n% Set POLY.\n%\n poly(1:40)= [ ...\n 1, 3, 7, 11, 13, 19, 25, 37, 59, 47, ...\n 61, 55, 41, 67, 97, 91, 109, 103, 115, 131, ...\n 193, 137, 145, 143, 241, 157, 185, 167, 229, 171, ...\n 213, 191, 253, 203, 211, 239, 247, 285, 369, 299 ];\n%\n% Check parameters.\n%\n if ( dim_num < 2 | dim_max < dim_num )\n fprintf ( 1, '\\n' );\n fprintf ( 1, 'SOBOL - Fatal error!\\n' );\n fprintf ( 1, ' The spatial dimension DIM_NUM should satisfy:\\n' );\n fprintf ( 1, ' 2 <= DIM_NUM <= %d\\n', dim_max );\n fprintf ( 1, ' But this input value is DIM_NUM = %d\\n', dim_num );\n return\n end\n\n atmost = 2^30 - 1;\n%\n% Find the number of bits in ATMOST.\n%\n maxcol = bit_hi1_base_2 ( atmost );\n%\n% Initialize row 1 of V.\n%\n v(1,1:maxcol) = 1;\n%\n% Initialize the remaining rows of V.\n%\n for ( i = 2 : dim_num )\n%\n% The bit pattern of the integer POLY(I) gives the form\n% of polynomial I.\n%\n% Find the degree of polynomial I from binary encoding.\n%\n j = poly(i);\n m = 0;\n\n while ( 1 )\n\n j = floor ( j / 2 );\n\n if ( j <= 0 )\n break;\n end\n\n m = m + 1;\n\n end\n%\n% We expand this bit pattern to separate components of the logical array INCLUD.\n%\n j = poly(i);\n for ( k = m : -1 : 1 )\n j2 = floor ( j / 2 );\n includ(k) = ( j ~= 2 * j2 );\n j = j2;\n end\n%\n% Calculate the remaining elements of row I as explained\n% in Bratley and Fox, section 2.\n%\n for ( j = m + 1 : maxcol )\n\n newv = v(i,j-m);\n l = 1;\n\n for ( k = 1 : m )\n\n l = 2 * l;\n\n if ( includ(k) )\n newv = exor ( newv, l * v(i,j-k) );\n end\n\n end\n\n v(i,j) = newv;\n\n end\n\n end\n%\n% Multiply columns of V by appropriate power of 2.\n%\n l = 1;\n for ( j = maxcol-1 : -1 : 1 )\n l = 2 * l;\n v(1:dim_num,j) = v(1:dim_num,j) * l;\n end\n%\n% RECIPD is 1/(common denominator of the elements in V).\n%\n recipd = 1.0E+00 / ( 2 * l );\n\n seed = floor ( seed );\n\n if ( seed < 0 )\n seed = 0;\n end\n\n if ( seed == 0 )\n\n l = 1;\n SOBOL_lastq(1:dim_num) = 0;\n\n elseif ( seed == SOBOL_seed + 1 )\n%\n% Find the position of the right-hand zero in SEED.\n%\n l = bit_lo0_base_2 ( seed );\n\n elseif ( seed <= SOBOL_seed )\n\n SOBOL_seed = 0;\n l = 1;\n SOBOL_lastq(1:dim_num) = 0;\n\n for ( seed_temp = SOBOL_seed : seed-1 )\n\n l = bit_lo0_base_2 ( seed_temp );\n\n for ( i = 1 : dim_num )\n SOBOL_lastq(i) = exor ( SOBOL_lastq(i), v(i,l) );\n end\n\n end\n\n l = bit_lo0_base_2 ( seed );\n\n elseif ( SOBOL_seed+1 < seed )\n\n for ( seed_temp = SOBOL_seed+1 : seed-1 )\n\n l = bit_lo0_base_2 ( seed_temp );\n\n for ( i = 1 : dim_num )\n SOBOL_lastq(i) = exor ( SOBOL_lastq(i), v(i,l) );\n end\n\n end\n\n l = bit_lo0_base_2 ( seed );\n\n end\n%\n% Check that the user is not calling too many times!\n%\n if ( maxcol < l )\n fprintf ( 1, '\\n' );\n fprintf ( 1, 'SOBOL - Fatal error!\\n' );\n fprintf ( 1, ' Too many calls!\\n' );\n fprintf ( 1, ' MAXCOL = %d\\n', maxcol );\n fprintf ( 1, ' L = %d\\n', l );\n return\n end\n%\n% Calculate the new components of QUASI.\n%\n for ( i = 1 : dim_num )\n\n quasi(i) = SOBOL_lastq(i) * recipd;\n\n SOBOL_lastq(i) = exor ( SOBOL_lastq(i), v(i,l) );\n\n end\n\n SOBOL_seed = seed;\n seed_new = seed + 1;\n", "meta": {"author": "canlab", "repo": "CanlabCore", "sha": "af242e120f0480c4feaeea90471c015a14f1f60e", "save_path": "github-repos/MATLAB/canlab-CanlabCore", "path": "github-repos/MATLAB/canlab-CanlabCore/CanlabCore-af242e120f0480c4feaeea90471c015a14f1f60e/CanlabCore/OptimizeDesign11/GA3/Sobol/sobol.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267118026095992, "lm_q2_score": 0.7248702761768248, "lm_q1q2_score": 0.5992588126762608}} {"text": "function tests = test_ft_preproc_bandpassfilter\n\n% MEM 1gb\n% WALLTIME 00:10:00\n% DEPENDENCY ft_preproc_bandpassfilter\n\nif nargout\n % assume that this is called by RUNTESTS\n tests = functiontests(localfunctions);\nelse\n % assume that this is called from the command line\n fn = localfunctions;\n for i=1:numel(fn)\n feval(fn{i});\n end\nend\n\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\nfunction testOptions(testCase)\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\nnchan = 8;\nnsample = 1000;\n\ndat = randn(nchan, nsample) + 1;\nFs = 1000;\nFbp = [1 35];\n\ninstabilityfix = [];\ndf = []; \nwintype = []; \ndev = []; \nplotfiltresp = [];\nusefftfilt = [];\n\nfilttypes = {'brickwall', 'firws' 'fir' 'firls' 'but'};\nfiltdirs = {'onepass' 'onepass-reverse' 'twopass' 'twopass-reverse' 'twopass-average' 'onepass-zerophase' 'onepass-reverse-zerophase' 'onepass-minphase'};\nfiltorders = {[] 1 2 4 8};\n\nresult = {};\nopts = {};\nfor i1 = 1:numel(filttypes)\n if isequal(filttypes{i1}, 'brickwall')\n opts{end+1} =[filttypes{i1}]; \n result{end+1} = ft_preproc_bandpassfilter(dat, Fs, Fbp, [], filttypes{i1}, [], instabilityfix, df, wintype, dev, plotfiltresp, usefftfilt);\n continue;\n elseif isequal(filttypes{i1}, 'but')\n sel2 = 1:5;\n sel3 = 2:4; % order 8 may become unstable, and thus requires an instabilityfix\n elseif isequal(filttypes{i1}, 'firws')\n sel2 = find(~contains(filtdirs, 'twopass')); % this leads to a filter that is not stable\n sel3 = 1; % the low number orders do not make sense at all for the finite impulse filters.\n else\n sel2 = 1:numel(filtdirs);\n sel3 = 1;\n end\n for i2 = sel2\n for i3 = sel3\n tmp = filtorders{i3};\n if isempty(tmp)\n tmp = 'defaultorder';\n elseif isnumeric(tmp)\n tmp = sprintf('order %d', tmp);\n end\n opts{end+1} = sprintf('%s_%s_%s', filttypes{i1}, filtdirs{i2}, tmp); \n result{end+1} = ft_preproc_bandpassfilter(dat, Fs, Fbp, filtorders{i3}, filttypes{i1}, filtdirs{i2}, instabilityfix, df, wintype, dev, plotfiltresp, usefftfilt);\n end\n end\nend\n\n% result{end+1} = ft_preproc_bandpassfilter(dat, Fs, Fbp, 8, 'but' , 'onepass' , 'split', [], [], [], [], []); % this one is instable\n% result{end+1} = ft_preproc_bandpassfilter(dat, Fs, Fbp, 8, 'but' , 'onepass-reverse' , 'split', [], [], [], [], []);\n% result{end+1} = ft_preproc_bandpassfilter(dat, Fs, Fbp, 8, 'but' , 'twopass' , 'split', [], [], [], [], []);\n% result{end+1} = ft_preproc_bandpassfilter(dat, Fs, Fbp, 8, 'but' , 'twopass-reverse' , 'split', [], [], [], [], []);\n% result{end+1} = ft_preproc_bandpassfilter(dat, Fs, Fbp, 8, 'but' , 'twopass-average' , 'split', [], [], [], [], []);\n\n% all iterations were done with (slightly) different options, hence the results should not be equal\nfor i=1:numel(result)\n for j=(i+1):numel(result)\n assert(~isequal(result{i}, result{j}), 'the results %d and %d should not be equal', i, j);\n end\nend\n\nfor i=1:size(result{1},1)\n for k=1:numel(result)\n for m=(k+1):numel(result)\n b(k,m) = result{k}(i,:)/result{m}(i,:);\n b(m,k) = result{m}(i,:)/result{k}(i,:);\n end\n B(:,:,i) = b;\n end\nend\nn = numel(result);\nfigure;imagesc((mean(B,3)+mean(B,3)')/2);\nset(gca, 'xtick', 1:n, 'ytick', 1:n, 'xticklabel', opts', 'yticklabel', opts', 'ticklabelinterpreter', 'none');\nset(gcf, 'position', [230 47 993 750]);\ncolorbar\naxis equal;axis tight\n", "meta": {"author": "fieldtrip", "repo": "fieldtrip", "sha": "c2039be598a02d86b39aae76bfa7aaa720f9801c", "save_path": "github-repos/MATLAB/fieldtrip-fieldtrip", "path": "github-repos/MATLAB/fieldtrip-fieldtrip/fieldtrip-c2039be598a02d86b39aae76bfa7aaa720f9801c/test/test_ft_preproc_bandpassfilter.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8267117940706734, "lm_q2_score": 0.724870282120402, "lm_q1q2_score": 0.5992588114002728}} {"text": "function [h,t,dat,d,m1,m2,sterr] = tor_fill_steplot(dat,color,varargin)\n% :Usage:\n% ::\n%\n% [h,t] = tor_fill_steplot(dat,color,[robust flag],[p-thresh],[x vector],[covs no interest])\n%\n% Plots a mean vector (mean of each column of dat)\n% surrounded by a fill with standard err bars\n%\n% If dat has 3 dimensions, then\n% the diff between dat(:,:,1) and dat(:,:,2) is\n% used as the difference for computing standard err\n% (as in repeated measures)\n%\n% if behavior is entered as optional argument, removes it before plotting\n% lines. Also returns adjusted output in d, dat\n% \n% Optional: robust flag (1/0), robust IRLS\n%\n% :Examples:\n% ::\n%\n% tor_fig;\n% tor_fill_steplot(dat,{'b' 'r'},0,.05,secs);\n\ndorobust = 0; pthresh = 0; x = 1:size(dat,2);\nt = []; m1 = []; m2 = []; X = [];\n\nif length(varargin) > 0, dorobust = varargin{1};,end\nif length(varargin) > 1, pthresh = varargin{2};,end\nif length(varargin) > 2, x = varargin{3};,end % small x, time\nif length(varargin) > 3, X = varargin{4};,end % big X, model matrix of covs\n\nif isempty(x), x = 1:size(dat,2);, end\n\n\n\n\nif length(size(dat)) > 2\n \n % remove covariates of no interest, if any\n % center covs and fit without intercept to preserve mean in data\n if ~isempty(X)\n disp('Adjusting for covariates.');\n X = scale(X,1); % center\n W = X * pinv(X);\n y = squeeze(dat(:,:,1));\n dat(:,:,1) = y - W * y;\n \n y = squeeze(dat(:,:,2));\n dat(:,:,2) = y - W * y;\n end\n \n d = dat(:,:,1) - dat(:,:,2);\n \n if dorobust\n [m1] = robust_mean(dat(:,:,1));\n [m2] = robust_mean(dat(:,:,2));\n [dummy,t,p,sterr] = robust_mean(d);\n else\n \n m1 = nanmean(dat(:,:,1));\n m2 = nanmean(dat(:,:,2));\n md = nanmean(d);\n sterr = ste(d);\n t = md ./ sterr;\n [h,p,ci,stat] = ttest(d);\n end\n \n if ~iscell(color), error('For two groups, color should be cell, e.g., {''r'' ''b''})');,end\n \n hold on; \n h(1) = plot(x,m1,color{1},'LineWidth',2);\n h(2) = plot(x,m2,color{2},'LineWidth',2);\n \n drawnow\n \n fill_around_line(m1,sterr,color{1},x);\n fill_around_line(m2,sterr,color{2},x);\n\n drawnow\n \n if pthresh\n % significance markers at top of plot.\n yval = max([m1 m2]) + .04 * max([m1 m2]);\n k = 1;\n df = size(d,1) - k;\n %tthr = tinv(1 - pthresh,df);\n tsig = (p < pthresh) .* t;\n \n wh = yval * (tsig > 0);%double((t > tthr)); wh(wh==0) = NaN; wh(wh>0) = yval;\n %plot(x,wh,color{1},'LineWidth',3);\n for i = 1:length(wh)\n if wh(i)\n text(x(i),wh(i),'*','Color',color{1}(1),'FontSize',24);\n end\n end\n \n %wh = yval(find(tsig < 0)); % double((t < -tthr)); wh(wh==0) = NaN; wh(wh>0) = yval;\n %plot(x,wh,color{2},'LineWidth',3);\n \n wh = yval * (tsig < 0);%double((t > tthr)); wh(wh==0) = NaN; wh(wh>0) = yval;\n %plot(x,wh,color{1},'LineWidth',3);\n for i = 1:length(wh)\n if wh(i)\n text(x(i),wh(i),'*','Color',color{2}(1),'FontSize',24);\n end\n end\n \n \n text(x(5),yval+.04 * max([m1 m2]),'Significant','FontSize',16);\n end\n \n drawnow\n\nelse\n \n if dorobust\n [m1,t,p,sterr] = robust_mean(dat(:,:,1));\n else\n m1 = nanmean(dat(:,:,1), 1);\n sterr = ste(dat);\n end\n \n if ~iscell(color), tmp = color; color = []; color{1} = tmp; end\n \n hold on; \n if ischar(color{1})\n h = plot(x,m1,color{1},'LineWidth',2);\n else\n h = plot(x,m1,'o-', 'Color', color{1},'LineWidth',2);\n end\n \n fill_around_line(m1,sterr,color{1},x);\n \nend\n\nreturn\n", "meta": {"author": "canlab", "repo": "CanlabCore", "sha": "af242e120f0480c4feaeea90471c015a14f1f60e", "save_path": "github-repos/MATLAB/canlab-CanlabCore", "path": "github-repos/MATLAB/canlab-CanlabCore/CanlabCore-af242e120f0480c4feaeea90471c015a14f1f60e/CanlabCore/Visualization_functions/tor_fill_steplot.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267117898012104, "lm_q2_score": 0.724870282120402, "lm_q1q2_score": 0.599258808305466}} {"text": "function w = dwt3D(x, J, af)\n\n% 3-D Discrete Wavelet Transform\n%\n% USAGE:\n% w = dwt3D(x, stages, af)\n% INPUT:\n% x - N1 by N2 by N3 matrix\n% 1) Ni all even\n% 2) min(Ni) >= 2^(J-1)*length(af)\n% J - number of stages\n% af - analysis filters\n% OUTPUT:\n% w - cell array of wavelet coefficients\n% EXAMPLE:\n% [af, sf] = farras;\n% x = rand(128,64,64);\n% w = dwt3D(x,3,af);\n% y = idwt3D(w,3,sf);\n% err = x-y; \n% max(max(max(abs(err))))\n%\n% WAVELET SOFTWARE AT POLYTECHNIC UNIVERSITY, BROOKLYN, NY\n% http://taco.poly.edu/WaveletSoftware/\n\nfor k = 1:J\n [x w{k}] = afb3D(x, af, af, af);\nend\nw{J+1} = x;\n\n", "meta": {"author": "thomaskuestner", "repo": "CS_MoCo_LAB", "sha": "a26e8e483624b2e4ee669e7a069ba9c74d2d2e4b", "save_path": "github-repos/MATLAB/thomaskuestner-CS_MoCo_LAB", "path": "github-repos/MATLAB/thomaskuestner-CS_MoCo_LAB/CS_MoCo_LAB-a26e8e483624b2e4ee669e7a069ba9c74d2d2e4b/reconstruction/matlab/CS_LAB_matlab/utils/utils_TRAFO/DTCWT/dwt3D.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8267117940706734, "lm_q2_score": 0.7248702761768248, "lm_q1q2_score": 0.5992588064866473}} {"text": "function [nuisance_ratio, rsquare_design, rsquare_nuis] = scn_component_rsquare(V, nuisanceX, designX)\n% Print a table of r-square values (variance explained) for each of V data\n% vectors by nuisance (mvmt, physio) and task-related predictors\n%\n% Designed to work with components\n%\n% :Examples:\n% ::\n%\n% % Typical operation\n% scn_component_rsquare(compscore, movement_params(1:157, :), X(1:157, :));\n%\n% % No design\n% scn_component_rsquare(compscore, movement_params(1:157, :));\n%\n% % Neither design nor nuisance, uses linear drift\n% scn_component_rsquare(compscore, []);\n%\n% ..\n% Tor Wager, Feb 2008\n% ..\n\n[t, m] = size(V);\n\nif nargin < 3, designX = []; end\n\nif isempty(nuisanceX) \n disp('Looking for nuisance covariates, but none found. Using linear drift.');\n nuisanceX = (1:t)'; \nend\n \ndisp('Variance in each component explained:')\n\n% Nuisance\nrsquare_nuis = get_rsquare(V, nuisanceX)';\n\nif ~isempty(designX)\nrsquare_design = get_rsquare(V, designX)';\nelse\n rsquare_design = .01 * ones(m, 1);\nend\n\nnuisance_ratio = rsquare_nuis ./ rsquare_design;\n\nnuis_related = find(nuisance_ratio > 2);\ntask_related = find(nuisance_ratio < 1);\n\n%rank_badness = sort(nuisance_ratio, 1, 'descend');\ndisp('All components');\nprint_matrix([(1:m)' rsquare_design rsquare_nuis nuisance_ratio], {'Comp.' 'R^2 Task' 'R^2 Nuisance' 'Ratio'});\nfprintf('\\n');\n\ndisp('Most task-related');\nif isempty(designX)\n disp('NO DESIGN INFORMATION.');\nelse\nprint_matrix([task_related rsquare_design(task_related) rsquare_nuis(task_related) nuisance_ratio(task_related)], {'Comp.' 'R^2 Task' 'R^2 Nuisance' 'Ratio'});\nend\nfprintf('\\n');\n\ndisp('Most nuisance-related');\nprint_matrix([nuis_related rsquare_design(nuis_related) rsquare_nuis(nuis_related) nuisance_ratio(nuis_related)], {'Comp.' 'R^2 Task' 'R^2 Nuisance' 'Ratio'});\nfprintf('\\n');\n\n\n%fprintf('\\tComp %3.0f : %3.0f%%\\n', j, rsquare(j)*100);\nend\n\nfunction rsquare = get_rsquare(V, X)\n\n [t, m] = size(V);\n \n for j = 1:m\n % Center component to avoid counting intercept in r-square?\n % Don't have to, doesn't matter because var operator is 2nd moment\n y = V(:, j); \n b = X \\ y;\n\n fits = X * b;\n\n rsquare(j) = var(fits) / var(y);\n \n end\n\n \nend\n", "meta": {"author": "canlab", "repo": "CanlabCore", "sha": "af242e120f0480c4feaeea90471c015a14f1f60e", "save_path": "github-repos/MATLAB/canlab-CanlabCore", "path": "github-repos/MATLAB/canlab-CanlabCore/CanlabCore-af242e120f0480c4feaeea90471c015a14f1f60e/CanlabCore/diagnostics/scn_component_rsquare.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267117940706734, "lm_q2_score": 0.7248702642896702, "lm_q1q2_score": 0.5992587966593964}} {"text": "% plot_lognorm_scat2_1d: Plots the log normalized 2nd order scattering\n% coefficients for 1d signals.\n% Usage\n% plot_lognorm_scat2_1d(S)\n% Input\n% S: The log normalized scattering coefficients.\n% Output\n% N/A\n% Description\n% Plots the second order log normalized scattering coefficients as a\n% function of j2-j1 (where 2^(-j1) is the first frequency, 2^(-j2) is the\n% second frequency) for various values of j1.\n\nfunction plot_lognorm_scat2_1d(S)\n\n% Settings\n\n% The lower limit of j2-j1\nlowlimit = -2;\n\n% Stop plotting j2-j1 at the max-earlystop\nearlystop = 2;\n\n% The values of j1 go up to max-earlyend\nearlyend = 1;\n\n%% Initialize\n\n% Adjust settings as needed\nearlyend = max(earlyend,earlystop);\n\n% Second order coefficients\nS2 = S{3};\n\n% Number of frequencies minus one\nmaxj1 = max(S2.meta.j(1,:));\n\n% Colormap\nC = jet(maxj1-earlyend+1);\n\n% Legend\nleg = cell(maxj1-earlyend+1,1);\n\n%% Loop through values of j1 and plot in terms of j2-j1\n\nfigure,hold on;\nfor j1=0:(maxj1-earlyend)\n indj1 = find(S2.meta.j(1,:)==j1);\n j2 = S2.meta.j(2,indj1);\n \n S2j1j2 = S2.signal(indj1);\n S2j1j2 = cat(2,S2j1j2{:});\n S2j1j2 = S2j1j2(1,:);\n \n [j2,indj2] = sort(j2,'ascend');\n S2j1j2 = S2j1j2(indj2);\n \n j2minj1 = j2-j1;\n indj2j1 = j2minj1 >= lowlimit;\n indj2j1((end-earlystop+1):end) = false;\n \n plot(j2minj1(indj2j1),S2j1j2(indj2j1),'Color',C(j1+1,:));\n leg{j1+1} = sprintf('%d',j1);\nend\nlegend(leg);\nhold off;\n\nend", "meta": {"author": "scatnet", "repo": "scatnet", "sha": "59d935afa20359845282a3518134e24244862c1f", "save_path": "github-repos/MATLAB/scatnet-scatnet", "path": "github-repos/MATLAB/scatnet-scatnet/scatnet-59d935afa20359845282a3518134e24244862c1f/display/plot_lognorm_scat2_1d.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8267117855317474, "lm_q2_score": 0.7248702702332476, "lm_q1q2_score": 0.5992587953834083}} {"text": "%% load some data\nload leq\n%% plot it\nplot(yy);, grid on\ntitle('1-D signal')\n%% embed it into a 3-D space with a delay of 10\nN=10;\nA=[yy(1:end-(N-1)),yy(N/2:end-N/2),yy(N:end)];\n%% plot it again\nfigure\nplot3(A(:,1),A(:,2),A(:,3))\ngrid on, axis tight\ntitle('3-D signal')", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/24320-algorithmic-trading-with-matlab-2009-update/takens.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8267117769928211, "lm_q2_score": 0.72487026428967, "lm_q1q2_score": 0.599258784280169}} {"text": "%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% Q = INVERSEKINEMATIC_SCARA(robot, T)\t\n% Solves the inverse kinematic problem for the SCARA example robot\n% where:\n% robot stores the robot parameters.\n% T is an homogeneous transform that specifies the position/orientation\n% of the end effector.\n%\n% A call to Q=INVERSEKINEMATIC_SCARA returns 2 possible solutions, thus,\n% Q is a 4x4 matrix where each column stores 4 feasible joint values.\n%\n% \n% Example code:\n%\n% robot=load_robot('example', 'scara');\n% q = [0 0 0 0];\t\n% T = directkinematic(robot, q);\n% %Call the inversekinematic for this robot\n% qinv = inversekinematic(robot, T);\n% %check that all of them are feasible solutions!\n% %and every Ti equals T\n% for i=1:2,\n% Ti = directkinematic(robot, qinv(:,i))\n% end\n%\n%\tSee also DIRECTKINEMATIC.\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\n% Copyright (C) 2012, by Arturo Gil Aparicio\n%\n% This file is part of ARTE (A Robotics Toolbox for Education).\n% \n% ARTE is free software: you can redistribute it and/or modify\n% it under the terms of the GNU Lesser General Public License as published by\n% the Free Software Foundation, either version 3 of the License, or\n% (at your option) any later version.\n% \n% ARTE is distributed in the hope that it will be useful,\n% but WITHOUT ANY WARRANTY; without even the implied warranty of\n% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n% GNU Lesser General Public License for more details.\n% \n% You should have received a copy of the GNU Leser General Public License\n% along with ARTE. If not, see .\nfunction q = inversekinematic_scara(robot, T)\n\nfprintf('\\nComputing inverse kinematics for the %s robot', robot.name);\n\n\n%initialize q\nq=zeros(4,2);\n\n%Evaluate the DH table to obtain geometric parameters\nd = eval(robot.DH.d);\na = eval(robot.DH.a);\n\n%Store geometric parameters\nL1=abs(d(1));\nL2=abs(a(1));\nL3=abs(a(2));\n\n%T= [ nx ox ax Px;\n% ny oy ay Py;\n% nz oz az Pz];\nPx=T(1,4);\nPy=T(2,4);\nPz=T(3,4);\n\n\n%Distance of the point to the origin of S0\nR = sqrt(Px^2+Py^2);\n\n%Compute angles\ngamma = real(acos((L2^2+R^2-L3^2)/(2*R*L2)));\nbeta = atan2(Py,Px); \ndelta = real(acos((L2^2+L3^2-R^2)/(2*L2*L3)));\n\n%find the last rotation for the two possible configurations\nq4_1= find_last_rotation(robot,[beta+gamma delta-pi L1-Pz 0], T);\nq4_2= find_last_rotation(robot,[beta-gamma pi-delta L1-Pz 0], T);\n\n%Arrange all possible solutions\nq=[beta+gamma beta-gamma;\n delta-pi pi-delta;\n L1-Pz L1-Pz;\n q4_1 q4_2];\n\n\n% Compute the last rotation\nfunction q4 = find_last_rotation(robot, q, T)\n\nU = T(1:3,1);\n\n%Recompute the DH table according to q1, q2 and q3\ntheta = eval(robot.DH.theta);\nd = eval(robot.DH.d);\na = eval(robot.DH.a);\nalpha = eval(robot.DH.alpha);\n\n%now compute the position/orientation of the system S3\nH=eye(4);\nfor i=1:3,\n H=H*dh(theta(i), d(i), a(i), alpha(i));\nend\n\nX3=H(1:3,1);\nY3=H(1:3,2);\n\ncoseno=X3'*U;\nseno=U'*Y3;\n%compute the last rotation\nq4=atan2(seno,coseno);\n\n\n\n", "meta": {"author": "4rtur1t0", "repo": "ARTE", "sha": "6e836f3156bb36af63b70bd93375c8ff4ee643c4", "save_path": "github-repos/MATLAB/4rtur1t0-ARTE", "path": "github-repos/MATLAB/4rtur1t0-ARTE/ARTE-6e836f3156bb36af63b70bd93375c8ff4ee643c4/robots/example/scara/inversekinematic_scara.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199795472731, "lm_q2_score": 0.7154239897159439, "lm_q1q2_score": 0.5992534276334974}} {"text": "function Gamma = simgamma_ltd(T,P,Pi,rate,L,refractory_period,grouping)\n%\n% Simulate state time courses with longer-than-order-1-markov time dependencies\n%\n% INPUTS:\n%\n% T Number of time points for each time series\n% P Transition probability matrix (K by K)\n% Pi Initial probabilities (K by 1)\n% rate The weights that model the contribution of the\n% latest L points are modelled by a Gamma\n% distribution, whose shape is 1 - and rate is\n% specified here\n% L The length of the history (in number of time points)\n% that influences the state at time t\n% refractory_period to prevent bursts of quick changes, refractory_period\n% can be set so that, after a change, you cannot change again \n% after 'refractory_period' number of iterations\n%\n% OUTPUTS\n%\n% Gamma simulated p(state | data)\n%\n% Author: Diego Vidaurre, OHBA, University of Oxford\n\nN = length(T); K = length(Pi);\n\nif nargin<4, rate = 2; end\nif nargin<5, L = 10; end \nif nargin<6, refractory_period = 2; end \nif nargin<7, grouping = []; end\n\nGamma = zeros(sum(T),K);\nweights = gampdf(0:L-1,1,rate)'; \nweights = weights / sum(weights);\nweights = weights(end:-1:1);\n\nfor n = 1:N\n if ~isempty(grouping)\n i = grouping(n);\n Pn = P(:,:,i); Pin = Pi(:,i)';\n else\n Pn = P; Pin = Pi;\n end \n Gammai = zeros(T(n),K);\n if any(Pin==1)\n Gammai(1,Pin==1) = 1;\n else\n Gammai(1,:) = mnrnd(1,Pin);\n end\n last_ch = Inf; \n for t = 2:L \n if last_ch < refractory_period\n Gammai(t,:) = Gammai(t-1,:); \n last_ch = last_ch + 1;\n else\n if t==2\n g = repmat(weights(end-t+2:end,1),1,K) .* Gammai(1:t-1,:);\n else\n g = sum(repmat(weights(end-t+2:end,1),1,K) .* Gammai(1:t-1,:));\n end\n g = g / sum(g);\n Gammai(t,:) = mnrnd(1,g*Pn);\n if any(Gammai(t,:)~=Gammai(t-1,:)), last_ch = 1; end\n Gammai(t,:) = Gammai(t,:) / sum(Gammai(t,:)); \n end\n end\n for t=L+1:T(n)\n if last_ch < refractory_period\n Gammai(t,:) = Gammai(t-1,:);\n last_ch = last_ch + 1;\n else\n g = sum(repmat(weights,1,K) .* Gammai(t-L:t-1,:));\n Gammai(t,:) = mnrnd(1,g*Pn);\n if any(Gammai(t,:)~=Gammai(t-1,:)), last_ch = 1; end\n end\n end\n t = (1:T(n)) + sum(T(1:n-1));\n Gamma(t,:) = Gammai;\nend\n\nend\n\n", "meta": {"author": "OHBA-analysis", "repo": "HMM-MAR", "sha": "bb0433b75482e473980791a2b30afe2012cf6578", "save_path": "github-repos/MATLAB/OHBA-analysis-HMM-MAR", "path": "github-repos/MATLAB/OHBA-analysis-HMM-MAR/HMM-MAR-bb0433b75482e473980791a2b30afe2012cf6578/simulate/simgamma_ltd.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8376199633332891, "lm_q2_score": 0.7154240018510026, "lm_q1q2_score": 0.5992534261981918}} {"text": "function [Population,Fitness] = EnvironmentalSelection(Population,N)\n% The environmental selection of SPEA2+SDE\n\n%------------------------------- Copyright --------------------------------\n% Copyright (c) 2023 BIMK Group. You are free to use the PlatEMO for\n% research purposes. All publications which use this platform or any code\n% in the platform should acknowledge the use of \"PlatEMO\" and reference \"Ye\n% Tian, Ran Cheng, Xingyi Zhang, and Yaochu Jin, PlatEMO: A MATLAB platform\n% for evolutionary multi-objective optimization [educational forum], IEEE\n% Computational Intelligence Magazine, 2017, 12(4): 73-87\".\n%--------------------------------------------------------------------------\n\n %% Calculate the fitness of each solution\n Fitness = CalFitness(Population.objs);\n\n %% Environmental selection\n Next = Fitness < 1;\n if sum(Next) < N\n [~,Rank] = sort(Fitness);\n Next(Rank(1:N)) = true;\n elseif sum(Next) > N\n Del = Truncation(Population(Next).objs,sum(Next)-N);\n Temp = find(Next);\n Next(Temp(Del)) = false;\n end\n % Population for next generation\n Population = Population(Next);\n Fitness = Fitness(Next);\nend\n\nfunction Del = Truncation(PopObj,K)\n% Select part of the solutions by truncation\n\n N = size(PopObj,1);\n \n %% Calculate the shifted distance between each two solutions\n Distance = inf(N);\n for i = 1 : N\n SPopObj = max(PopObj,repmat(PopObj(i,:),N,1));\n for j = [1:i-1,i+1:N]\n Distance(i,j) = norm(PopObj(i,:)-SPopObj(j,:));\n end\n end\n \n %% Truncation\n Del = false(1,N);\n while sum(Del) < K\n Remain = find(~Del);\n Temp = sort(Distance(Remain,Remain),2);\n [~,Rank] = sortrows(Temp);\n Del(Remain(Rank(1))) = true;\n end\nend", "meta": {"author": "BIMK", "repo": "PlatEMO", "sha": "c5b5b7c37a9bb42689a5ac2a0d638d9c4f5693d5", "save_path": "github-repos/MATLAB/BIMK-PlatEMO", "path": "github-repos/MATLAB/BIMK-PlatEMO/PlatEMO-c5b5b7c37a9bb42689a5ac2a0d638d9c4f5693d5/PlatEMO/Algorithms/Multi-objective optimization/SPEA2+SDE/EnvironmentalSelection.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.837619947119304, "lm_q2_score": 0.7154240018510026, "lm_q1q2_score": 0.5992534145983177}} {"text": "function energy = computeEnergyBinaryPairwise( unaryTerms, pairwiseTerms, labels )\n%computeEnergyBinaryPairwise computes the value of the energy with unary and pairwise potentials\n\n%% check input\nnumLabels = 2;\n\nif ~isnumeric(unaryTerms) || ~ismatrix(unaryTerms) || size(unaryTerms, 2) ~= 2\n error('Incorrect format for unaryTerms, has to be numNodes x 2')\nend\nnumNodes = size(unaryTerms, 1);\n\nif ~isnumeric(pairwiseTerms) || ~ismatrix(pairwiseTerms) || size(pairwiseTerms, 2) ~= 6\n error('Incorrect format for pairwiseTerms, has to be numEdges x 6')\nend\nnumEdges = size(pairwiseTerms, 1);\n\nif ~isnumeric(labels) || ~isvector(labels) || length(labels) ~= numNodes\n error('Incorrect format for labels, has to be numNodes x 1')\nend\nlabels = labels(:);\nif any(labels > numLabels) || any(labels < 1)\n error('Incorrect values for labels, has to be an integer from 1 to numLabels')\nend\n\n%% computation\nenergy = sum( unaryTerms((1 : numNodes)' + numNodes * (labels - 1) ) );\n\nlabel1 = labels(pairwiseTerms(:, 1));\nlabel2 = labels(pairwiseTerms(:, 2));\nlabelMap = [ 3, 4; 5, 6];\njointLabelMap = labelMap( label1 + 2 * (label2 - 1) );\n\nenergy = energy + sum( pairwiseTerms( (1 : numEdges)' + numEdges * (jointLabelMap - 1) ) );\n\nend\n\n", "meta": {"author": "aosokin", "repo": "cnn_head_detection", "sha": "80624e7a25c62f7b504fa6f4d830136beb66eec8", "save_path": "github-repos/MATLAB/aosokin-cnn_head_detection", "path": "github-repos/MATLAB/aosokin-cnn_head_detection/cnn_head_detection-80624e7a25c62f7b504fa6f4d830136beb66eec8/pairwiseModel/energyMinimization/computeEnergyBinaryPairwise.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8376199552262967, "lm_q2_score": 0.7154239836484144, "lm_q1q2_score": 0.5992534051514037}} {"text": "function rchy = realized_hayashi_yoshida(priceA,timeA,priceB,timeB,timeType,samplingType,samplingInterval,overlap)\n% Computed the Hayashi-Yoshida estimator of quadratic covariation, and allows for\n% the empirical-performance motivated K-lead-and-lag version similar to Drost and Nijman (1997).\n%\n% USAGE:\n% [RCHY] = realized_hayashi_yoshida_(PRICEA,TIMEA,PRICEB,TIMEB,TIMETYPE,SAMPLINGTYPE,SAMPLINGINTERVAL,OVERLAP)\n%\n% INPUTS:\n% PRICEA - mA by 1 vector of high frequency prices\n% TIMEA - mA by 1 vector of times where TIMEB(i) corresponds to PRICEA(i)\n% PRICEA - mB by 1 vector of high frequency prices\n% TIMEA - mB by 1 vector of times where TIMEB(i) corresponds to PRICEB(i)\n% TIMETYPE - String describing the way times are measured\n% 'wall' 24-hour clock of the form HHMMSS, e.g. 101543 or 153217\n% 'seconds' Time measures in seconds past midnight.\n% TIME must satisfy 0<=TIME<86400\n% 'unit' Unit normalized date format, e.g. .1, .234, .9\n% Unit normalized times are more general than the\n% other types and can be applied to data from more\n% than one calendar day\n% SAMPLINGTYPE - String describing the type of sampling to use when\n% filtering PRICE\n% 'CalendarTime' - Sample in calendar time using\n% observations separated by SAMPLINGINTERVAL\n% seconds. If TIMETYPE is 'unit',\n% SAMPLINGINTERVAL must be between 0 and 1 and\n% represents the fraction of the sample to skip\n% when sampling.\n% 'CalendarUniform' - Sample in calendar time using\n% SAMPLINGINTERVAL observations spread uniformly\n% between TIME(1) and TIME(m)\n% 'BusinessTime' - Sample in business (tick) time\n% using observation separated by SAMPLINGINTERVAL\n% ticks\n% 'BusinessUniform' - Sample in business (tick)\n% time using observations uniformly spaced in\n% business time.\n% 'Fixed' - Sample at specific points in time. When\n% using fixed, SAMPLINGINTERVAL must be a n by 1 vector\n% of times with the same TIMETYPE as TIME (i.e.\n% seconds if TIME is in seconds)\n% SAMPLINGINTERVAL - Scalar integer or n by 1 vector whose meaning depends on the\n% selected SAMPLINGTYPE\n% OVERLAP - Number of ticks to overlap when computing the HY estimator. The original HY\n% estimator uses 0, which corresponds to the maximum likelihood estimator for\n% price processes whose observation times are driven by independent Poisson\n% processes. Empirically this estimator performs poorly because prices are\n% not a vector semi-martingale and using a larger number of lags can alleviate\n% this problem.\n%\n% OUTPUTS:\n% RCHY - The K-lead-and-lag Hayashi-Yoshida covariance estimator\n%\n% COMMENTS:\n% Filtering the price in calendar time allow the creation of a Hayashi-Yoshida corrected\n% calendar-time sampled realized covariance. The value in SAMPLINGTYPE is applied to price A and\n% then the realized HY estimator is computed using the filtered price of A and the filtered times\n% of A, and all observations of B. Price filtering is done using realized_price_filter\n%\n% EXAMPLES:\n% % Standard use with all prices with wall time prices\n% RCHY = realized_hayashi_yoshida(PRICEA,TIMEA,PRICEB,TIMEB,'wall','BusinessTime',1,0)\n%\n% % 10 lead and lag RCHY with all prices with wall time prices\n% RCHY = realized_hayashi_yoshida(PRICEA,TIMEA,PRICEB,TIMEB,'wall','BusinessTime',1,10)\n%\n% % 1-minute realized covariance with a HY correction\n% RCHY = realized_hayashi_yoshida(PRICEA,TIMEA,PRICEB,TIMEB,'wall','CalendarTime',60,0)\n%\n% See also REALIZED_MULTIVARIATE_KERNEL, REALIZED_COVARIANCE, REALIZED_KERNEL, REALIZED_VARIANCE,\n% REALIZED_RANGE, REALIZED_QUANTILE_VARIANCE\n\n% Copyright: Kevin Sheppard\n% kevin.sheppard@economics.ox.ac.uk\n% Revision: 1 Date: 5/1/2008\n\n\n\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% Input Checking\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%\nif nargin<7 || nargin>8\n error('Seven or eight inputs required.')\nend\nif size(priceA,2)>size(priceA,1)\n priceA=priceA';\nend\nif size(priceA,2)>1\n error('PRICEA must be a m by 1 vector.')\nend\nif size(timeA,2)>size(timeA,1)\n timeA=timeA';\nend\nif any(diff(timeA)<0)\n error('TIMEA must be sorted and increasing')\nelseif any(diff(timeA)==0)\n warning('oxfordRealized:realizedPriceFilter','TIMEA contains multiple entries with the same value. This creates an ambiguity and FILTEREDPRICE will contain the last price if TIMEA does not only unique elements.')\nend\nif size(timeA,2)>1 || length(timeA)~=length(priceA)\n error('TIMEA must be a m by 1 vector.')\nend\n% Inserted to protect against inputing integer times\ntimeA = double(timeA);\nif size(priceB,2)>size(priceB,1)\n priceB=priceB';\nend\nif size(priceB,2)>1\n error('PRICEB must be a m by 1 vector.')\nend\nif size(timeB,2)>size(timeB,1)\n timeB=timeB';\nend\nif any(diff(timeB)<0)\n error('TIMEB must be sorted and increasing')\nelseif any(diff(timeB)==0)\n warning('oxfordRealized:realizedPriceFilter','TIMEB contains multiple entries with the same value. This creates an ambiguity and FILTEREDPRICE will contain the last price if TIMEB does not only unique elements.')\nend\nif size(timeB,2)>1 || length(timeB)~=length(priceB)\n error('TIMEB must be a m by 1 vector.')\nend\n% Inserted to protect against inputing integer times\ntimeB = double(timeB);\n\n% make sure the intersection is non-empty\nif ~(min(timeB)size(samplingInterval,1)\n samplingInterval=samplingInterval';\n end\n if ~(any(samplingInterval>=t0Original) && any(samplingInterval<=tTOriginal))\n error('At least one sampling interval must be between min(TIME) and max(TIME) when using ''Fixed'' as SAMPLINGTYPE.')\n end\n if any(diff(samplingInterval)<=0)\n error('When using ''Fixed'' as SAMPLINGTYPE the vector of sampling times in SAMPLINGINTERVAL must be sorted and strictly increasing.')\n end\nend\n\nif strcmp(timeType,'unit') && strcmp(samplingType,'calendartime')\n % samplingInterval must be between 0 and 1\n if samplingInterval>1\n error('When TIMETYPE is ''unit'' and SAMPLINGTYPE is ''CalendarTime'', SAMPLINGINTERVAL must also be in ''unit'' terms, and so must be between 0 and 1')\n end\nend\n\nif nargin==7\n overlap = 0;\nelseif overlap<0 || floor(overlap)~=overlap || max(size(overlap))>1\n error('OVERLAP must be a non-negative integer.')\nend\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n% Input Checking\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%\n\n\n\n% Price A is the base price, price B is the other price. First sample priceA according to\n% samplingType and samplingInterval, then use the actual times of these to estimate the HY\n% respecting the value in overlap\n\nif ~intersectionIsEmpty\n % First filter the price\n [filteredPriceA,filteredTimeA,actualTimeA] = realized_price_filter(priceA,timeA,timeType,samplingType,samplingInterval);\n\n % Then call the core routine\n rchy = realized_hayashi_yoshida_core(filteredPriceA,actualTimeA,priceB,timeB,overlap);\nelse\n rchy = 0;\nend\n\n\n\n\n\nfunction [rchy,times] = realized_hayashi_yoshida_core(priceA,timeA,priceB,timeB,overlap)\n% Core routine for computing the Hayashi-Yoshida estimator of quadratic covariation, and allows for\n% the empirical-performance motivated K-lead-and-lag version similar to Drost and Nijman (1997).\n%\n% USAGE:\n% [RCHY,TIMES] = realized_hayashi_yoshida_core(PRICEA,TIMEA,PRICEB,TIMEB,OVERLAP)\n%\n% INPUTS:\n% PRICEA - mA by 1 vector of high frequency prices\n% TIMEA - mA by 1 vector of times where TIMEB(i) corresponds to PRICEA(i)\n% PRICEA - mB by 1 vector of high frequency prices\n% TIMEA - mB by 1 vector of times where TIMEB(i) corresponds to PRICEB(i)\n% OVERLAP - [OPTIONA] Number of ticks to overlap when computing the HY estimator. The\n% original HY estimator uses 0, which corresponds to the maximum likelihood\n% estimator for price processes whose observation times are driven by\n% independent Poisson processes. Empirically this estimator performs poorly\n% because prices are not a vector semi-martingale and using a larger number\n% of lags can alleviate this problem. If omitted OVERLAP = 0.\n%\n% OUTPUTS:\n% RCHY - The K-lead-and-lag Hayashi-Yoshida covariance estimator\n% TIMES - A mA by 1 matrix of time stamps contains the times where the prices were\n% sampled for computing the returns in the HY estimator. This is mostly for\n% diagnostic purposes.\n%\n% COMMENTS:\n% This is a helper function of realized_hayashi_yoshida and does no input checking. In general\n% it should not be directly called.\n%\n% See also REALIZED_MULTIVARIATE_KERNEL, REALIZED_COVARIANCE, REALIZED_KERNEL, REALIZED_VARIANCE,\n% REALIZED_RANGE, REALIZED_QUANTILE_VARIANCE\n\n% Copyright: Kevin Sheppard\n% kevin.sheppard@economics.ox.ac.uk\n% Revision: 1 Date: 5/1/2008\n\npriceA = log(priceA);\npriceB = log(priceB);\ntimeA = double(timeA);\ntimeB = double(timeB);\n% Price A is the base price, price B is the one which will move\n\n% First find the first time that B is available before timeA(1). If it is empty then find the first\n% timeA(1) which is weakly after the timeB(1)\nnA = size(priceA,1);\nnB = size(priceB,1);\n\nif timeA(1)timeB(nB)\n % A ends after B, so the easy solution is to project forward the last price B to the\n % time of the last A. This will generate a 0 return but makes the algorithm easier.\n timeB=[timeB;timeA(nA)];\n priceB=[priceB;priceB(nB)];\n nB = size(priceB,1);\nend\n\n\n\n\n% Initialize the indices for A and B\nindexA = 1;\nindexB = find(timeB<=timeA(1), 1,'last');\nif overlap>0\n indexB = max(indexB-overlap,1); % Make sure that indexB is >= 1\nend\n\n% Initialize rchy and the times\nrchy = 0;\ntimes = zeros(nA-1,4);\nwhile indexAtimeA(indexA)\n indexB = indexB - 1;\n end\nend\n", "meta": {"author": "bashtage", "repo": "mfe-toolbox", "sha": "9622b6c546bc6d649fd9bf0a36a7fcd53872e04a", "save_path": "github-repos/MATLAB/bashtage-mfe-toolbox", "path": "github-repos/MATLAB/bashtage-mfe-toolbox/mfe-toolbox-9622b6c546bc6d649fd9bf0a36a7fcd53872e04a/realized/realized_hayashi_yoshida.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.837619947119304, "lm_q2_score": 0.7154239897159438, "lm_q1q2_score": 0.5992534044337503}} {"text": "function [idx, frame] = registration_target(frames, useGPU)\n\n%% Parameters\n[ly, lx, nFrames] = size(frames);\ndata = single(frames);\n\nif nargin < 2\n useGPU = false;\nend\n\n%% Prepare common arrays\n% Taper mask\n[ys, xs] = ndgrid(1:ly, 1:lx);\nys = abs(ys - mean(ys(:)));\nxs = abs(xs - mean(xs(:)));\nmY = max(ys(:)) - 4;\nmX = max(xs(:)) - 4;\nslope = 1.2; % was 2\n\nmaskMul = single(1./(1 + exp((ys - mY)/slope)) ./(1 + exp((xs - mX)/slope)));\nmaskOffset = mean(data(:,:,1))*(1 - maskMul);\n% Smoothing filter in frequency domain\nsigma = 0.76; %.76 with mask\nhgx = exp(-(((0:lx-1) - fix(lx/2))/sigma).^2);\nhgy = exp(-(((0:ly-1) - fix(ly/2))/sigma).^2);\nhg = hgy'*hgx;\nfhg = real(fftn(ifftshift(single(hg/sum(hg(:))))));\n\neps0 = single(1e-20);\nif useGPU\n data = gpuArray(data);\n% peakCorrMatrix = zeros(nFrames, nFrames, 'single', 'gpuArray');\n% else\n% peakCorrMatrix = zeros(nFrames, nFrames, 'single');\nend\n\ncorrRanges = zeros(nFrames, 3, 'single');\n\n[a, b] = ndgrid(1:nFrames, 1:nFrames);\ndata = fft2(bsxfun(@plus, maskOffset, bsxfun(@times, maskMul, data)));\ndata = data./(eps0 + abs(data));\ncdata = conj(data);\nfor fi = 1:nFrames\n % compute correlation map of frame fi with every other frame\n cmap = bsxfun(@times, data(:,:,a(:,fi)).*cdata(:,:,b(:,fi)), fhg);\n cmap = real(ifft2(cmap));\n % find peak of each correlation map\n peaks = gather(max(reshape(cmap, ly*lx, nFrames), [], 1));\n % compute first quartile of peak correlations, ignoring result\n % from correlation of this frame with itself.\n corrRanges(fi,:) = prctile(peaks((1:nFrames) ~= fi), [25 50 75]);\nend\n% find the frame with the best correlations with other frames\n[bestCorr, idx] = max(corrRanges(:,1));\n% plot(corrRanges)\nframe = frames(:,:,idx);\n% peakCorrMatrix = gather(peakCorrMatrix);\n% [mxi, idx] = max(prctile(peakCorrMatrix, 25, 1))\n% [mnx, mni] = min(prctile(peakCorrMatrix, 25, 2));\n% figure, imagesc(peakCorrMatrix);\n% figure, plot(1:nFrames, peakCorrMatrix(mxi,:), 1:nFrames, peakCorrMatrix(mni,:))\nend", "meta": {"author": "cortex-lab", "repo": "Suite2P", "sha": "c6a8ea9f01ffc8555429978e7fe97f843ad5b6d5", "save_path": "github-repos/MATLAB/cortex-lab-Suite2P", "path": "github-repos/MATLAB/cortex-lab-Suite2P/Suite2P-c6a8ea9f01ffc8555429978e7fe97f843ad5b6d5/preRegistration/registration_target.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9005297807787537, "lm_q2_score": 0.6654105653819836, "lm_q1q2_score": 0.5992220305713043}} {"text": "% Set system limits\nlims = mr.opts('MaxGrad',32,'GradUnit','mT/m',...\n 'MaxSlew',130,'SlewUnit','T/m/s',...\n 'rfRingdownTime', 30e-6, 'rfDeadtime', 100e-6); \n\nseq=mr.Sequence(lims); % Create a new sequence object\nfov=220e-3; Nx=256; Ny=256; % Define FOV and resolution\n\nfoe=200e-3; % Field of excitation\ntargetWidth=22.5e-3; % Diameter of target excitation pattern\nn=8; % Number of spiral turns\nT=8e-3; % Pulse duration\n\n\n% Define spiral k-space trajectory\nkMax=(2*n)/foe/2; % Units of 1/m (not rad/m)\ntk=0:seq.gradRasterTime:T-seq.gradRasterTime;\nkx=kMax*(1-tk/T).*cos(2*pi*n*tk/T);\nky=kMax*(1-tk/T).*sin(2*pi*n*tk/T);\n\n% Define RF pulse\ntr=0:seq.rfRasterTime:T-seq.rfRasterTime;\nkxRf=interp1(tk,kx,tr,'linear','extrap');\nkyRf=interp1(tk,ky,tr,'linear','extrap');\nbeta=2*pi*kMax*targetWidth/2/sqrt(2); % Gaussian width in k-space\nsignal0 = exp(-beta.^2.*(1-tr/T).^2).*sqrt((2*pi*n*(1-tr/T)).^2+1);\nsignal = signal0.*(1 + exp(-1j.*2*pi*5e-2*(kxRf + kyRf)));\n\n% Add gradient ramps\n[kx,ky,signal]=mr.addRamps({kx,ky},'rf',signal);\n\nrf = mr.makeArbitraryRf(signal,20*pi/180,'system',lims);\ngxRf = mr.makeArbitraryGrad('x',mr.traj2grad(kx));\ngyRf = mr.makeArbitraryGrad('y',mr.traj2grad(ky));\n\n% Define other gradients and ADC events\ndeltak=1/fov;\ngx = mr.makeTrapezoid('x','FlatArea',Nx*deltak,'FlatTime',6.4e-3);\nadc = mr.makeAdc(Nx,'Duration',gx.flatTime,'Delay',gx.riseTime);\ngxPre = mr.makeTrapezoid('x','Area',-gx.area/2,'Duration',2e-3);\nphaseAreas = ((0:Ny-1)-Ny/2)*deltak;\n\n% Refocusing pulse and spoiling gradients\n%[rf180, gz] = mr.makeBlockPulse(pi,'Duration',1e-3,'SliceThickness',5e-3);\n[rf180, gz] = mr.makeSincPulse(pi,'system',lims,'Duration',3e-3,...\n 'SliceThickness',5e-3,'apodization',0.5,'timeBwProduct',4);\n\ngzSpoil = mr.makeTrapezoid('z','Area',gx.area,'Duration',2e-3);\n\n%%% Calculate timing (TE=20ms, TR=500ms)\ndelayTE1=ceil((20e-3/2 - mr.calcDuration(gzSpoil) - mr.calcDuration(rf180)/2)/seq.gradRasterTime)*seq.gradRasterTime;\ndelayTE2=delayTE1 - mr.calcDuration(gxPre) - mr.calcDuration(gx)/2;\ndelayTR=500e-3 - 20e-3 - mr.calcDuration(rf) - mr.calcDuration(gx)/2;\n\n%% Loop over phase encodes and define sequence blocks\nfor i=1:Ny\n seq.addBlock(rf,gxRf,gyRf);\n seq.addBlock(mr.makeDelay(delayTE1));\n seq.addBlock(gzSpoil);\n seq.addBlock(rf180,gz);\n seq.addBlock(gzSpoil);\n seq.addBlock(mr.makeDelay(delayTE2));\n gyPre = mr.makeTrapezoid('y','Area',phaseAreas(i),'Duration',2e-3);\n seq.addBlock(gxPre,gyPre);\n seq.addBlock(gx,adc);\n seq.addBlock(mr.makeDelay(delayTR));\nend\n\n%% check whether the timing of the sequence is correct\n[ok, error_report]=seq.checkTiming;\n\nif (ok)\n fprintf('Timing check passed successfully\\n');\nelse\n fprintf('Timing check failed! Error listing follows:\\n');\n fprintf([error_report{:}]);\n fprintf('\\n');\nend\n\n%%\nseq.setDefinition('Name', 'se_selRF');\n\nseq.write('selectiveRf.seq'); % Write to pulseq file\nseq.plot();\n\nreturn\n\n\n%% Write to file\n% The sequence is written to file in compressed form according to the file\n% format specification using the |write| method.\n%seq.setDefinition('Scan_ID',2068);\n%seq.setDefinition('Recon_Mode',1);\n%seq.write('external.seq')\n\n%seq.plot\n\n", "meta": {"author": "pulseq", "repo": "pulseq", "sha": "b4c8fee2a1ffa491d53bd6f507cba2029bf32835", "save_path": "github-repos/MATLAB/pulseq-pulseq", "path": "github-repos/MATLAB/pulseq-pulseq/pulseq-b4c8fee2a1ffa491d53bd6f507cba2029bf32835/matlab/demoSeq/writeSelectiveRf.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9005297861178929, "lm_q2_score": 0.6654105521116443, "lm_q1q2_score": 0.5992220221736881}} {"text": "function mags = gtmmag(net, latent_data)\n%GTMMAG\tMagnification factors for a GTM\n%\n%\tDescription\n%\t MAGS = GTMMAG(NET, LATENTDATA) takes a GTM structure NET, and\n%\tcomputes the magnification factors for each point the latent space\n%\tcontained in LATENTDATA.\n%\n%\tSee also\n%\tGTM, GTMPOST, GTMLMEAN\n%\n\n%\tCopyright (c) Ian T Nabney (1996-2001)\n\nerrstring = consist(net, 'gtm');\nif ~isempty(errstring)\n error(errstring);\nend\n\nJacs = rbfjacob(net.rbfnet, latent_data);\nnlatent = size(latent_data, 1);\nmags = zeros(nlatent, 1);\ntemp = zeros(net.rbfnet.nin, net.rbfnet.nout);\nfor m = 1:nlatent\n temp = squeeze(Jacs(m, :, :)); % Turn into a 2d matrix\n mags(m) = sqrt(det(temp*temp'));\nend\n", "meta": {"author": "bayesnet", "repo": "bnt", "sha": "bebba5f437b4e1e29169f0f3669df59fb5392e62", "save_path": "github-repos/MATLAB/bayesnet-bnt", "path": "github-repos/MATLAB/bayesnet-bnt/bnt-bebba5f437b4e1e29169f0f3669df59fb5392e62/netlab3.3/gtmmag.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8128673269042767, "lm_q2_score": 0.7371581741774411, "lm_q1q2_score": 0.5992117945492538}} {"text": "function [ S, f, Serr ]= mtspectrumc_unequal_length_trials( data, movingwin, params, sMarkers )\n\n% This routine computes the multi-taper spectrum for a given set of unequal length segments. It is\n% based on modifications to the Chronux routines. The segments are continuously structured in the \n% data matrix, with the segment boundaries given by markers. Below,\n% movingwin is used in a non-overlaping way to partition each segment into\n% various windows. Th spectrum is evaluated for each window, and then the\n% window spectrum estimates averaged. Further averaging is conducted by\n% repeating the process for each segment. \n%\n% Inputs: \n%\n% data = data( samples, channels )- here segments must be stacked\n% as explained in the email \n% movingwin = [window winstep] i.e length of moving\n% window and step size. Note that units here have\n% to be consistent with units of Fs. If Fs=1 (ie normalized)\n% then [window winstep]should be in samples, or else if Fs is\n% unnormalized then they should be in time (secs). \n% sMarkers = N x 2 array of segment start & stop marks. sMarkers(n, 1) = start\n% sample index; sMarkers(n,2) = stop sample index for the nth segment\n% params = see Chronux help on mtspecgramc\n%\n% Output:\n%\n% S frequency x channels\n% f frequencies x 1\n% Serr (error bars) only for err(1)>=1\n%\n%\n\niwAvg = 1; % 0=no weighted average, 1=weighted average\ndebug = 0; % will display intermediate calcs. \n\nif nargin < 2; error('Unequal length trials:: Need data and window parameters'); end;\nif nargin < 3; params=[]; end;\nif isempty( sMarkers ), error( 'Unequal length trials:: Need Markers...' ); end\n[ tapers, pad, Fs, fpass, err, trialave, params ] = getparams( params );\nif nargout > 2 && err(1)==0; \n% Cannot compute error bars with err(1)=0. change params and run again.\n error('Unequal length trials:: When Serr is desired, err(1) has to be non-zero.');\nend;\n\n% Set moving window parameters to no-overlapping\nif abs(movingwin(2) - movingwin(1)) >= 1e-6, disp( 'avgSpectrum:: Warming: Window parameters for averaging should be non-overlapping. Set movingwin(2) = movingwin(1).' ); end\n\nwLength = round( Fs * movingwin(1) ); % number of samples in window\nwStep = round( movingwin(2) * Fs ); % number of samples to step through\n\n% Check whether window lengths satify segment length > NW/2\nif ( wLength < 2*tapers(1) ), error( 'avgSpectrum:: movingwin(1) > 2*tapers(1)' ); end\n\n% Left align segment markers for easier coding\nsM = ones( size( sMarkers, 1 ), 2 ); \nsM( :, 2 ) = sMarkers( :, 2 ) - sMarkers( :, 1 ) + 1;\n\n% min-max segments \nNmax = max( sM(:,2) ); Nmin = min( sM(:,2) );\nif ( Nmin < 2*tapers(1) ), error( 'avgSpectrum:: Smallest segment length > 2*tapers(1). Change taper settings' ); end\n\n% max time-sample length will be the window length. \nnfft = 2^( nextpow2( wLength ) + pad );\n[ f, findx ] = getfgrid( Fs, nfft, fpass); \n\n% Precompute all the tapers\nsTapers = tapers;\nsTapers = dpsschk( sTapers, wLength, Fs ); % compute tapers for window length\n\nnChannels = size( data, 2 ); \nnSegments = size( sMarkers, 1 );\n\nif debug\n disp( ['Window Length = ' num2str(wLength)] );\n disp( ['Window Step = ' num2str(wStep)] );\n disp( ' ' );\nend\n\ns = zeros( length(f), nChannels );\nserr = zeros( 2, length(f), nChannels );\nS = zeros( length(f), nChannels );\nSerr = zeros( 2, length(f), nChannels );\nnWins = 0;\nfor sg = 1 : nSegments\n % Window lengths & steps fixed above\n % For the given segment, compute the positions & number of windows\n N = sM(sg,2); \n wStartPos = 1 : wStep : ( N - wLength + 1 );\n nWindows = length( wStartPos );\n if nWindows\n nWins = nWins + nWindows; % for averaging purposes\n\n w=zeros(nWindows,2);\n for n = 1 : nWindows\n w(n,:) = [ wStartPos(n), (wStartPos(n) + wLength - 1) ]; % nWindows x 2. just like segment end points\n end\n\n % Shift window limits back to original sample-stamps\n w(:, 1) = w(:,1) + (sMarkers( sg, 1 ) - 1);\n w(:, 2) = w(:,2) + (sMarkers( sg, 1 ) - 1);\n\n if debug\n disp( ['Segment Start/Stop = ' num2str( w(1,1) ) ' ' num2str( w(end,2) ) ] );\n disp( ['Min / Max Window Positions = ' num2str( min(w(:,1)) ) ' ' num2str( max(w(:,1)) ) ] );\n disp( ['Total Number of Windows = ' num2str(nWindows) ]);\n disp( ' ' );\n end\n\n % Pile up window segments similar to segment pileup\n wData = zeros( wLength, nChannels, nWindows ); %initialize to avoid fragmentation\n for n = 1:nWindows\n %wData( :, :, n ) = detrend( data( w(n,1):w(n,2), : ), 'constant' );\n wData( :, :, n ) = detrend( data( w(n,1):w(n,2), : ) );\n end\n\n % J1 = frequency x taper x nWindows\n % J2 = frequency x taper x nWindows x nChannels\n J2 = zeros( length(f), tapers(2), nWindows, nChannels ); J2 = complex( J2, J2 );\n for c = 1 : nChannels\n J1 = mtfftc( squeeze(wData( :, c, : )), sTapers, nfft, Fs ); % FFT for the tapered data\n J2( :, :, :, c ) = J1(findx,:,:);\n end\n % J2 = frequency x taper x nWindows x nChannels\n % Inner mean = Average over tapers => frequency x nWindows x nChannels\n % Outer mean = Average over windows => frequency x nChannels\n dim1 = [length(f), nWindows, nChannels];\n dim2 = [length(f), nChannels];\n % s = frequency x nChannels\n s = reshape( squeeze( mean( reshape( squeeze( mean( conj(J2).*J2, 2 ) ), dim1), 2 ) ), dim2 );\n\n % Now treat the various \"windowed data\" as \"trials\"\n % serr = 2 x frequency x channels. Output from specerr = 2 x frequency x 1\n for c = 1 : nChannels\n serr( :, :, c ) = specerr( squeeze( s(:, c ) ), squeeze( J2(:,:,:, c ) ), err, 1 );\n end\n \n if iwAvg\n % Segment Weighted error estimates.\n S = S + nWindows*s;\n Serr = Serr + nWindows*serr;\n else\n S = S + s;\n Serr = Serr + serr;\n end\n\n else\n if debug, disp(['avgSpectrum:: Zero windows for segment: ' num2str(sg) ]); end\n end\nend\n\n% Segment Weighted error estimates.\n% Only over those that had non-zero windows\nif nWins && iwAvg\n S=S/nWins; Serr=Serr/nWins;\nend\nif ~nWins\n if debug, disp(['avgCoherence:: No segment long enough with movingwin parameters found. Reduce movingwin.' ]); end\nend\n\n\n\n\n", "meta": {"author": "buzsakilab", "repo": "buzcode", "sha": "2d700a38b3c2a860ad1333be90f14d7a37a72815", "save_path": "github-repos/MATLAB/buzsakilab-buzcode", "path": "github-repos/MATLAB/buzsakilab-buzcode/buzcode-2d700a38b3c2a860ad1333be90f14d7a37a72815/externalPackages/chronux_2_12/spectral_analysis/continuous/mtspectrumc_unequal_length_trials.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8128673223709251, "lm_q2_score": 0.7371581684030623, "lm_q1q2_score": 0.5992117865136527}} {"text": "%IM_BDILATION Fixed mapping for binary dilation (DIP_Image)\n%\n%\tB = IM_BDILATION(A,N,CONNECTIVITY,EDGE_CONDITION)\n%\tB = A*IM_BDILATION([],N,CONNECTIVITY,EDGE_CONDITION)\n%\tB = A*IM_BDILATION(N,CONNECTIVITY,EDGE_CONDITION)\n%\n% INPUT\n% A Dataset with binary object images dataset (possibly multi-band)\n% N Number of iterations (default 1)\n% CONNECTIVITY See BDILATION\n% EDGE_CONDITION Value of edge, default 0\n%\n% OUTPUT\n% B Dataset with dilated images\n%\n% SEE ALSO (PRTools Guide)\n% DATASETS, DATAFILES, DIP_IMAGE, BDILATION\n\n% Copyright: R.P.W. Duin, duin@ph.tn.tudelft.nl\n% Faculty of Applied Physics, Delft University of Technology\n% P.O. Box 5046, 2600 GA Delft, The Netherlands\n\nfunction b = im_bdilation(varargin)\n\n\targin = shiftargin(varargin,'scalar');\n argin = setdefaults(argin,[],1,-2,0);\n if mapping_task(argin,'definition')\n b = define_mapping(argin,'fixed');\n b = setname(b,'Image dilation');\n else\n [a,n,connect,edgecon] = deal(argin{:});\n if isa(a,'prdataset') % allows datafiles too\n isobjim(a);\n b = filtim(a,mfilename,{n,connect,edgecon});\n elseif isa(a,'double') || isa(a,'dip_image') % here we have a single image\n if checktoolbox('dipimage')\n a = dip_image(a,'bin');\n b = bdilation(a,n,connect,edgecon);\n else\n diplibwarn\n b = bwmorph(a,'dilate',n);\n end\n else\n error('Illegal input')\n end\n\tend\n\t\nreturn\n", "meta": {"author": "marianux", "repo": "ecg-kit", "sha": "c8e3de47c54a9214138143676d2aa546b0540dd2", "save_path": "github-repos/MATLAB/marianux-ecg-kit", "path": "github-repos/MATLAB/marianux-ecg-kit/ecg-kit-c8e3de47c54a9214138143676d2aa546b0540dd2/common/prtools/im_bdilation.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8128673269042767, "lm_q2_score": 0.7371581568543044, "lm_q1q2_score": 0.599211780467842}} {"text": "classdef LIRCMOP1 < PROBLEM\n% \n% Constrained benchmark MOP with large infeasible regions\n\n%------------------------------- Reference --------------------------------\n% Z. Fan, W. Li, X. Cai, H. Huang, Y. Fang, Y. You, J. Mo, C. Wei, and E.\n% Goodman, An improved epsilon constraint-handling method in MOEA/D for\n% CMOPs with large infeasible regions, Soft Computing, 2019, 23:\n% 12491-12510.\n%------------------------------- Copyright --------------------------------\n% Copyright (c) 2023 BIMK Group. You are free to use the PlatEMO for\n% research purposes. All publications which use this platform or any code\n% in the platform should acknowledge the use of \"PlatEMO\" and reference \"Ye\n% Tian, Ran Cheng, Xingyi Zhang, and Yaochu Jin, PlatEMO: A MATLAB platform\n% for evolutionary multi-objective optimization [educational forum], IEEE\n% Computational Intelligence Magazine, 2017, 12(4): 73-87\".\n%--------------------------------------------------------------------------\n\n% This function is written by Wenji Li\n \n methods\n %% Default settings of the problem\n function Setting(obj)\n obj.M = 2;\n if isempty(obj.D); obj.D = 30; end\n obj.lower = zeros(1,obj.D);\n obj.upper = ones(1,obj.D);\n obj.encoding = ones(1,obj.D);\n end\n %% Calculate objective values and constraint violations\n function Population = Evaluation(obj,varargin)\n X = varargin{1};\n X = max(min(X,repmat(obj.upper,size(X,1),1)),repmat(obj.lower,size(X,1),1));\n x_odd = X(:,3:2:end);\n x_even = X(:,2:2:end);\n g_1 = sum((x_odd - sin(0.5 * pi * X(:,1))).^2,2);\n g_2 = sum((x_even - cos(0.5 * pi * X(:,1))).^2,2);\n PopObj(:,1) = X(:,1) + g_1;\n PopObj(:,2) = 1 - X(:,1) .^ 2 + g_2;\n PopCon(:,1) = (0.5 - g_1).*(0.51 - g_1);\n PopCon(:,2) = (0.5 - g_2).*(0.51 - g_2);\n Population = SOLUTION(X,PopObj,PopCon,varargin{2:end});\n obj.FE = obj.FE + length(Population);\n end\n %% Generate points on the Pareto front\n function R = GetOptimum(obj,N)\n R(:,1) = linspace(0,1,N)';\n R(:,2) = 1 - R(:,1).^2;\n R = R + 0.5;\n end\n %% Generate the image of Pareto front\n function R = GetPF(obj)\n R = obj.GetOptimum(100);\n end\n end\nend", "meta": {"author": "BIMK", "repo": "PlatEMO", "sha": "c5b5b7c37a9bb42689a5ac2a0d638d9c4f5693d5", "save_path": "github-repos/MATLAB/BIMK-PlatEMO", "path": "github-repos/MATLAB/BIMK-PlatEMO/PlatEMO-c5b5b7c37a9bb42689a5ac2a0d638d9c4f5693d5/PlatEMO/Problems/Multi-objective optimization/LIR-CMOP/LIRCMOP1.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128673133042218, "lm_q2_score": 0.7371581684030623, "lm_q1q2_score": 0.5992117798300582}} {"text": "function segment_length = p07_boundary_segment_length ( segment_index, h )\n\n%*****************************************************************************80\n%\n%% P07_BOUNDARY_SEGMENT_LENGTH returns boundary segment lengths in problem 07.\n%\n% Discussion:\n%\n% No attempt has been made here to accurately compute a value of N\n% which would guarantee that the boundary would be divided into pieces\n% of length no more than H. The curve is a little too complicated\n% to make this easy to do.\n%\n% Moreover, the points that will be generated will only be equally\n% spaced in their X argument, not in their arc length.\n%\n% Licensing:\n%\n% This code is distributed under the GNU LGPL license.\n%\n% Modified:\n%\n% 12 April 2009\n%\n% Author:\n%\n% John Burkardt\n%\n% Reference:\n%\n% Per-Olof Persson and Gilbert Strang,\n% A Simple Mesh Generator in MATLAB,\n% SIAM Review,\n% Volume 46, Number 2, June 2004, pages 329-345.\n%\n% Parameters:\n%\n% Input, integer SEGMENT_INDEX, the index of one of the boundary segments.\n%\n% Input, real H, the suggested spacing between points.\n%\n% Output, integer SEGMENT_LENGTH, the number of points in the segment.\n%\n if ( h <= 0.0 )\n fprintf ( 1, '\\n' );\n fprintf ( 1, 'P07_BOUNDARY_SEGMENT_LENGTH - Fatal error!' );\n fprintf ( 1, ' Nonpositive H = %f\\n', h );\n error ( 'P07_BOUNDARY_SEGMENT_LENGTH - Fatal error!' );\n end\n\n if ( segment_index == 1 )\n\n n = round ( 10.0 * pi / h );\n n = max ( n, 13 );\n segment_length = n;\n\n else\n\n fprintf ( 1, '\\n' );\n fprintf ( 1, 'P07_BOUNDARY_SEGMENT_LENGTH - Fatal error!' );\n fprintf ( 1, ' Illegal SEGMENT_INDEX = %d\\n', segment_index );\n error ( 'P07_BOUNDARY_SEGMENT_LENGTH - Fatal error!' );\n\n end\n\n return\nend\n", "meta": {"author": "johannesgerer", "repo": "jburkardt-m", "sha": "1726deb4a34dd08a49c26359d44ef47253f006c1", "save_path": "github-repos/MATLAB/johannesgerer-jburkardt-m", "path": "github-repos/MATLAB/johannesgerer-jburkardt-m/jburkardt-m-1726deb4a34dd08a49c26359d44ef47253f006c1/test_triangulation/p07_boundary_segment_length.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8128672997041659, "lm_q2_score": 0.7371581626286833, "lm_q1q2_score": 0.5992117651108622}} {"text": "close all; clear all; clc;\nrng('default');\n\nA = [3 2; 2 6];\nX = [ 2 1 0 4; \n -2 2 0 4];\nB = A * X;\n\nsolver = SPX_SteepestDescent(A, B);\nx = solver.solve();\nsolver.printResults();\n\n\n\n", "meta": {"author": "indigits", "repo": "sparse-plex", "sha": "43cae2978f62938d001baaa03308a2a717ee6c9b", "save_path": "github-repos/MATLAB/indigits-sparse-plex", "path": "github-repos/MATLAB/indigits-sparse-plex/sparse-plex-43cae2978f62938d001baaa03308a2a717ee6c9b/examples/optimization/convex_optimization/steepest_descent/ex_steepest_descent.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9099070011518829, "lm_q2_score": 0.6584175072643413, "lm_q1q2_score": 0.599098699540795}} {"text": "function [oa, pa, K, CM] = USFE_LPP(HSI, Tr, Te, dim, Trees)\n[nx,ny,nz]=size(HSI);\ndata=reshape(HSI,nx*ny,nz);\n[mappedX, mapping] = lpp(data, dim);\nFE_lpp=reshape(mappedX,nx,ny,dim);\n[acc_Mean,acc_std,CM]=RF_ntimes_overal(FE_lpp,Tr,Te,Trees);\npa=acc_Mean(1:dim,1);\noa=acc_Mean(dim+2,1);\nK=acc_Mean(dim+3,1);", "meta": {"author": "BehnoodRasti", "repo": "HyFTech-Hyperspectral-Shallow-Deep-Feature-Extraction-Toolbox", "sha": "effc9ee5970306a2e822b1831c32ab5580c1bbfe", "save_path": "github-repos/MATLAB/BehnoodRasti-HyFTech-Hyperspectral-Shallow-Deep-Feature-Extraction-Toolbox", "path": "github-repos/MATLAB/BehnoodRasti-HyFTech-Hyperspectral-Shallow-Deep-Feature-Extraction-Toolbox/HyFTech-Hyperspectral-Shallow-Deep-Feature-Extraction-Toolbox-effc9ee5970306a2e822b1831c32ab5580c1bbfe/ShallowFE/UFE/USFE_LPP.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.9099069962657177, "lm_q2_score": 0.658417500561683, "lm_q1q2_score": 0.5990986902248625}} {"text": "function [rc,fval,it] = ARjones(ti,xi,rcinit,p)\n\nnobs = length(xi);\n\nopties = optimset('Display','off','TolX',.001/sqrt(nobs),'TolFun',.0001);\n\n[rc_tan,fval,exitflag,output]= fminunc('Jonesfit',tan(.5*pi*rcinit),opties,ti,xi,p);\nrc = 2/pi*atan(rc_tan);\nit = output.iterations;\n", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/18429-armasel-for-irregular-or-missing-data/ARjones.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.9099070011518829, "lm_q2_score": 0.6584174938590246, "lm_q1q2_score": 0.5990986873432034}} {"text": "% simple demo to convert a polygon mesh into a voxel representation\n\n% code is 99.99% based on\n% [1] http://www.mathworks.com/matlabcentral/fileexchange/24086-polygon2voxel\n% [2] http://www.mathworks.com/matlabcentral/fileexchange/21044-3d-voxelizer\n\n% % Compile the c-coded function\n% mex polygon2voxel_double.c -v\n\nload model;\n\nvertices = vertices - repmat(mean(vertices,1),size(vertices,1),1);\n\nFV.faces = faces;\nFV.vertices = vertices;\n\nVolume=polygon2voxel(FV,[20 20 20],'auto');\n\n%% visualization 1\nfigure\n[X,Y,Z]=ind2sub(size(Volume),find(Volume(:)));\nplot3(X,Y,Z,'.');\naxis equal;\nxlabel('x');\nylabel('y');\nzlabel('z');\n\n%% visualization 2\n% 3d pirnter style visualization to add layer by layer\n\ncareMask = imdilate((Volume),ones(2,2,2));\nfigure,plot3D(careMask,1,'timed', 0.1)\nhold on;%plot3D(Volume,1,'b','*')\n saveas(gcf,sprintf('/Users/shurans/Dropbox/ModelNet/ECCV2014_sub/MaskVideo/%05d.png',21 ));\nviewA =33:5:176;\nfor i =1:length(viewA)\n view(viewA(i),28);\n saveas(gcf,sprintf('/Users/shurans/Dropbox/ModelNet/ECCV2014_sub/MaskVideo/%05d.png',21+i ));\nend\n%%\n%{\n%% visualization 3\nfigure\nfor i=1:size(Volume,1)\n imagesc(squeeze(Volume(i,:,:)));\n axis equal;\n axis tight;\n axis off\n title(i);\n pause(0.1);\nend\n\nfor i=1:size(Volume,2)\n imagesc(squeeze(Volume(:,i,:)));\n axis equal;\n axis tight;\n axis off\n title(i);\n pause(0.1);\nend\n\nfor i=1:size(Volume,3)\n imagesc(squeeze(Volume(:,:,i)));\n axis equal;\n axis tight;\n axis off\n title(i);\n pause(0.1);\nend\n%}", "meta": {"author": "zhirongw", "repo": "3DShapeNets", "sha": "6a6cc71a9231051866092c94486ae967ac533d34", "save_path": "github-repos/MATLAB/zhirongw-3DShapeNets", "path": "github-repos/MATLAB/zhirongw-3DShapeNets/3DShapeNets-6a6cc71a9231051866092c94486ae967ac533d34/voxelization/demo.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.877476800298183, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5989426221057289}} {"text": "here=pwd;\ncd /home/bernard/Data/ABC/apascal\nattrs=dlmread('all-perimage.attributes');\nclasses=dlmread('all.classid');\ncd (here);\nclasses=classes+1;\n\nnClasses=length(unique(classes));\n[nInstances, nAttrs]=size(attrs);\n\nclassesAttrs=zeros(nClasses*3,nAttrs);\nclassesCells=cell(1,nClasses);\n\nfor i=1:nInstances\n class=classes(i);\n signature=attrs(i,:);\n classesCells{class}=[classesCells{class}; signature];\nend\ncounter=1;\nfor class=1:nClasses\n classesAttrs(counter,:)=mean(classesCells{class});\n classesAttrs(counter+1,:)=mean(classesCells{class})+0.5*std(classesCells{class});\n classesAttrs(counter+2,:)=mean(classesCells{class})-0.5*std(classesCells{class});\n counter=counter+3;\nend\n", "meta": {"author": "bernard24", "repo": "Embarrassingly-simple-ZSL", "sha": "700e92b1f7aebaf5a262c061803a789b082cca97", "save_path": "github-repos/MATLAB/bernard24-Embarrassingly-simple-ZSL", "path": "github-repos/MATLAB/bernard24-Embarrassingly-simple-ZSL/Embarrassingly-simple-ZSL-700e92b1f7aebaf5a262c061803a789b082cca97/stkernelaPY/getMinMaxAttributes.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767874818408, "lm_q2_score": 0.6825737408694988, "lm_q1q2_score": 0.5989426133576303}} {"text": "%% Author: epokh\n%% Website: www.epokh.org/drupy\n%% This software is under GPL\n\nclf\nclear\n%%Cartesian manipulator with an RPY wrist\npx=2.3;\npy=1.7;\npz=7.4;\n\nfia=32;\nfio=178;\nfin=4;\nTcartesian=Tras(px,py,pz);\nTorient=RPY(fia,fio,fin);\n\n%%The trasformation matrix is:\nTend=Tcartesian*Torient;\nfigure(1);\nplot3(0,0,0,'r');\nplotT(Tend);\ntitle('Cartesian manipulator example');\n%%Cylindrical manipulator with an Euler wrist\nTcyl=Tcyl(62,8.2,5.2)*Euler(32,15,17);\nfigure(2);\nplot3(0,0,0,'r');\nplotT(Tcyl);\ntitle('Cylindrical manipulator example');\n%%Spherical maninupaltor with an Euler an RPY wrist\nTsfer=Tsfer(40,50,10)*RPY(10,0,10);\nfigure(3);\nplot3(0,0,0,'r');\nplotT(Tsfer);\ntitle('Spherical manipulator example');\n\n%%Invert the Euler transformation\neuwrist=Euler(32,15,17);\n[fi1,fio,fi2]=invEuler(euwrist);\nfprintf('Invers euler angles %d %d %d \\n',fi1,fio,fi2);\nrpywrist=RPY(5,10,15);\n[fia,fio,fin]=invRPY(rpywrist);\nfprintf('Invers rpy angles %d %d %d \\n',fia,fio,fin);", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/14886-robotic-toolbox/somExamples.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767810736693, "lm_q2_score": 0.682573740869499, "lm_q1q2_score": 0.5989426089835809}} {"text": "% The original source code is from https://github.com/zhengliu6699/imageFusionMetrics/blob/master/metricChenBlum.m\n% The interface is modified by the authors of VIFB to integrate it into VIFB. \n\nfunction res=metricsQcb(img1,img2,fused)\n\n fused = double(fused); \n img1 = double(img1);\n img2 = double(img2);\n % Get the size of img \n [m,n,b] = size(fused); \n [m1,n1,b1] = size(img2);\n \n if b == 1\n g = Qcb(img1,img2,fused);\n res = g;\n elseif b1 == 1\n for k = 1 : b \n g(k) = Qcb(img1(:,:,k),img2,fused(:,:,k)); \n end \n res = mean(g); \n else \n for k = 1 : b \n g(k) = Qcb(img1(:,:,k),img2(:,:,k),fused(:,:,k)); \n end \n res = mean(g); \n end\n\n\nend\n\nfunction output = Qcb(im1, im2, fused)\n\n % function res=metricChenBlum(im1,im2,fused)\n %\n % This function implements Yin Chen's algorithm for fusion metric.\n % im1, im2 -- input images;\n % fused -- fused image;\n %\n % IMPORTANT: The size of the images need to be 2X. \n % See also: evalu_fusion.m\n %\n % Z. Liu [July 2009] %\n\n % Ref: A new automated quality assessment algorithm for image fusion, Image and Vision Computing, 27 (2009) 1421-1432 \n % By Yin Chen et al.\n % \n\n im1 = im2double(im1);\n im2 = im2double(im2);\n fused = im2double(fused);\n\n im1=normalize1(im1);\n im2=normalize1(im2);\n fused=normalize1(fused);\n\n %% set up some constant values for experiment\n\n f0=15.3870;\n f1=1.3456;\n a=0.7622;\n\n % parameters for local constrast computation\n k=1;\n h=1;\n p=3; %2.4;\n %p=2.4;\n q=2;\n Z=0.0001;\n sigma=2;\n %% caculate the quality Q\n\n [hang,lie]=size(im1);\n\n %DoG filter\n %DoG1\n %HH=hang/2; LL=lie/2;\n HH=hang/30; LL=lie/30;\n\n %DoG2\n %HH=hang/4; LL=lie/4;\n\n %DoG3\n %HH=hang/8; LL=lie/8;\n\n [u,v]=freqspace([hang,lie],'meshgrid');\n u=LL*u; v=HH*v;\n r=sqrt(u.^2+v.^2);\n\n Sd=exp(-(r/f0).^2)-a*exp(-(r/f1).^2);\n\n % constrast sensitivity filtering\n fused1=ifft2(ifftshift(fftshift(fft2(im1)).*Sd));\n fused2=ifft2(ifftshift(fftshift(fft2(im2)).*Sd));\n ffused=ifft2(ifftshift(fftshift(fft2(fused)).*Sd));\n\n %--------------------\n %fused1=normalize1(fused1);\n %fused2=normalize1(fused2);\n %ffused=normalize1(ffused);\n\n % local contrast computation\n % one level of contrast\n G1=gaussian2d(hang,lie,2);\n G2=gaussian2d(hang,lie,4);\n\n\n % filtering in frequency domain\n C1=contrast(G1,G2,fused1);\n C1=abs(C1); % I add this. (see your notes)\n C1P=(k*(C1.^p))./(h*(C1.^q)+Z);\n\n C2=contrast(G1,G2,fused2);\n C2=abs(C2); % I add this.\n C2P=(k*(C2.^p))./(h*(C2.^q)+Z);\n\n Cf=contrast(G1,G2,ffused);\n Cf=abs(Cf); % I add this.\n CfP=(k*(Cf.^p))./(h*(Cf.^q)+Z);\n\n % contrast preservation calculation\n mask=(C1P y; lie (L) -> x\n\nH=floor((n1-1)/2);\nL=floor((n2-1)/2);\n\n\n[x,y]=meshgrid(-15:15,-15:15);\nG=exp(-(x.*x+y.*y)/(2*sigma*sigma))/(2*pi*sigma*sigma);\n\n%This is to normalize\n%G=G/sum(G(:));\nres=G;\nend\n\n%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%\nfunction res=contrast(G1,G2,im)\n\n%[hang,lie]=size(im);\n\n%FG1=fft2(G1,hang,lie);\n%FG2=fft2(G2,hang,lie);\n%fused=fft2(im);\n\n%buff=real(ifft2(FG1.*fused));\n%buff1=real(ifft2(FG2.*fused));\n\nbuff=filter2(G1,im,'same');\nbuff1=filter2(G2,im,'same');\n\nres=buff./buff1-1;\nend\n\nfunction RES=normalize1(data)\n\n % function RES=normalize1(data)\n %\n % This function is to NORMALIZE the data. \n % The data will be in the interval 0-255 (gray level) and pixel value has\n % been rounded to an integer.\n % \n % See also: normalize.m \n %\n % Z. Liu @NRCC (Aug 24, 2009)\n\n data=double(data);\n da=max(data(:));\n xiao=min(data(:));\n if (da==0 & xiao==0)\n RES=data;\n else\n newdata=(data-xiao)/(da-xiao);\n RES=round(newdata*255);\n end\nend", "meta": {"author": "xingchenzhang", "repo": "VIFB", "sha": "7a89c52b46cfe52dd4d93d4f93cf367a0ed3f8fa", "save_path": "github-repos/MATLAB/xingchenzhang-VIFB", "path": "github-repos/MATLAB/xingchenzhang-VIFB/VIFB-7a89c52b46cfe52dd4d93d4f93cf367a0ed3f8fa/metrics/metricsQcb.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8774767906859264, "lm_q2_score": 0.6825737279551494, "lm_q1q2_score": 0.5989426042126131}} {"text": "function sys = probability(c)\n% PROBABILITY Create basis for chance constraint\n%\n% EXAMPLE:\n% The following example computes the largest value t such that the\n% probability that a zero mean unit variance of a Gaussian variable is\n% larger than t, is larger than 0.9 \n%\n% w = sdpvar(1,1);\n% t = sdpvar(1);\n% Model = [probability(a >= t) >= 0.9,uncertain(a,'normal',0,eye(1))];\n% solvesdp(derandomize(Model),-t)\n\nif isa(c,'constraint') | isa(c,'lmi')\n if ~is(c,'elementwise')\n error('Probability constraints only applicable to single elementwise constraints');\n else\n sys.Constraint = c;\n sys = class(sys,'probability');\n end\nelse\n error('Probability constraints only applicable to single elementwise constraints');\nend", "meta": {"author": "yalmip", "repo": "YALMIP", "sha": "f6d5a6d4222a4d722de30bffb43cae4b3e13b860", "save_path": "github-repos/MATLAB/yalmip-YALMIP", "path": "github-repos/MATLAB/yalmip-YALMIP/YALMIP-f6d5a6d4222a4d722de30bffb43cae4b3e13b860/extras/@probability/probability.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8774767810736692, "lm_q2_score": 0.6825737344123242, "lm_q1q2_score": 0.5989426033175598}} {"text": "function [ftps2] = mGal2ftps2(mGal)\n% Convert acceleration from milligals to feet per second-squared\n% Chad A. Greene 2012\nftps2 = mGal*3.28083333e-5; \nend", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/35258-unit-converters/unit_converters/mGal2ftps2.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8774767874818408, "lm_q2_score": 0.6825737214979745, "lm_q1q2_score": 0.5989425963595673}} {"text": "function equalizedData = dfe_frac(data, trainingSymbols, nFTaps, nBTaps, SamplesPerSymbol, Constellation, channelDelay)\n\n\ninputBuffer = zeros(nFTaps,1);\ndecisionBuffer = zeros(nBTaps,1);\n\nforwardTaps = [1; zeros(nFTaps-1,1)];\nbackwardTaps = [zeros(nBTaps,1)];\n\nnumTrainingSymbols = length(trainingSymbols);\n\nind = 0;\nequalizedData = complex(zeros(length(data),1));\nmu = 0.001;\n\nfor s=1:SamplesPerSymbol:length(data)\n ind = ind + 1;\n \n % Add data to buffer\n inputBuffer = [data(s:s+SamplesPerSymbol-1); inputBuffer(1:end-SamplesPerSymbol)];\n \n % Fill equalizer\n if s<=channelDelay\n continue\n end\n \n % Apply equalizer\n eqOut = forwardTaps'*inputBuffer - backwardTaps'*decisionBuffer;\n \n % Make decision\n [~,i] = min(abs(Constellation - eqOut));\n d = Constellation(i);\n \n % Determine error\n if s<=numTrainingSymbols\n e = trainingSymbols(ind-channelDelay/SamplesPerSymbol) - eqOut;\n else\n e = d - eqOut;\n end\n e = conj(e);\n \n % Update taps\n forwardTaps = forwardTaps + mu*e*inputBuffer;\n %backwardTaps = backwardTaps - mu*e*decisionBuffer;\n \n % Update decision buffer\n decisionBuffer = [d; decisionBuffer(1:end-1)];\n \n % Output\n equalizedData(ind) = eqOut;\nend\n%s = channelDelay/SamplesPerSymbol+1;\n%[equalizedData(s:s+100-1), trainingSymbols(1:100), data(s:s+100-1)]\n\nend", "meta": {"author": "analogdevicesinc", "repo": "MathWorks_tools", "sha": "5f8df06d4fc2f4832ed9ec8b722fb750b2261f20", "save_path": "github-repos/MATLAB/analogdevicesinc-MathWorks_tools", "path": "github-repos/MATLAB/analogdevicesinc-MathWorks_tools/MathWorks_tools-5f8df06d4fc2f4832ed9ec8b722fb750b2261f20/targeting_models/modem-qpsk/FloatingPoint/private/dfe_frac.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267830311354, "lm_q2_score": 0.6893056231680122, "lm_q1q2_score": 0.5988871871023361}} {"text": "function g = gammaFun(j, k)\n%GAMMAFUN Get a function handle to a gamma function.\n% G = GAMMAFUN(J, K) returns a function handle to the gamma function (J, K).\n%\n% See also EXPINTEG/GAMMAEVAL.\n\n% Copyright 2017 by The University of Oxford and The Chebfun Developers.\n% See http://www.chebfun.org/ for Chebfun information.\n\n% Trivial case:\nif ( j == 0 )\n g = @(z) (exp(k*z) - 1)./z;\n \n% Compute them recursively using the recurrence formula:\nelse\n g = @(z) 0*z;\n for m = 1:j\n gm = expinteg.gammaFun(j-m, k);\n g = @(z) g(z) + (-1)^(m-1)/m*gm(z);\n end\n if ( j <= k )\n g = @(z) (g(z) - nchoosek(k, j))./z;\n else\n g = @(z) g(z)./z;\n end\nend\n\nend", "meta": {"author": "chebfun", "repo": "chebfun", "sha": "8c49396a55e46ddd57a1d108c6a8f32e37536d54", "save_path": "github-repos/MATLAB/chebfun-chebfun", "path": "github-repos/MATLAB/chebfun-chebfun/chebfun-8c49396a55e46ddd57a1d108c6a8f32e37536d54/@expinteg/gammaFun.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8688267762381843, "lm_q2_score": 0.6893056231680122, "lm_q1q2_score": 0.5988871824199168}} {"text": "function plot_Maps4(sFilename)\n%\n%\n%\nload(sFilename)\n\n%% plot results mean z values\ncmin=-4;cmax=4;\nfigure_w_normalized_uicontrolunits('Name','Z-Value','Position',[100 25 400 400]);\nmData=nan(size(median(params.mZ,1, 'omitnan')));\nmData=median(params.mZ,1, 'omitnan');\n% mData=params.mZ;\npcolor(params.vX,params.vY,...\n reshape(mData,...\n size(params.vY,1),size(params.vX,1)));\nh=colorbar;\n% set(h,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'median(z)')\ncolormap(jet);\nxlabel('longitude');\nylabel('latitude');\nshading interp;\nhold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\nplot_WiemerWyss1994\nxlim([-117.1 -115.6]);\nylim([33 35.2]);\n\n% figure_w_normalized_uicontrolunits('Name','Std Z-Value');\n% mData=nan(size(mean(params.mZ,'omitnan')));\n% mData=std(params.mZ, 'omitnan');\n% pcolor(params.vX,params.vY,...\n% reshape(mData,...\n% size(params.vY,1),size(params.vX,1)));\n% h=colorbar;\n% % set(h,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'std(z)')\n% colormap(jet);\n% xlabel('longitude');\n% ylabel('latitude');\n% shading interp;\n% hold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\n\n%\n% figure_w_normalized_uicontrolunits('Name','Z-probability by cross-comparison');\n% pcolor(params.vX,params.vY,...\n% reshape(calc_ProbColorbar2Value(1-params.vPcrZ),...\n% size(params.vY,1),size(params.vX,1)));\n% plot_ProbColorbar2(cmin, cmax);\n% % set(gca,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'P(z)')\n%\n% xlabel('longitude');\n% ylabel('latitude');\n% shading interp;\n% hold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\n% % colorbar\n\n\nfigure_w_normalized_uicontrolunits('Name','Z-probability by overlap','Position',[100 25 400 400]);\npcolor(params.vX,params.vY,...\n reshape(calc_ProbColorbar2Value(1-params.vPolZ),...\n size(params.vY,1),size(params.vX,1)));\nxlabel('longitude');\nylabel('latitude');\nplot_ProbColorbar2(cmin, cmax);\n% set(gca,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'P(z)')\nshading interp;\nhold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\nplot_WiemerWyss1994\nxlim([-117.1 -115.6]);\nylim([33 35.2]);\n\n%% plot results mean B-values\ncmin=-4;cmax=4;\n% figure_w_normalized_uicontrolunits('Name','Median Beta-Value');\n% mData=nan(size(median(-params.mB, 'omitnan')));\n% mData=median(params.mB, 'omitnan');\n% pcolor(params.vX,params.vY,...\n% reshape(mData,...\n% size(params.vY,1),size(params.vX,1)));\n% h=colorbar;\n% % set(h,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'median(1-B)')\n% colormap(jet);\n% xlabel('longitude');\n% ylabel('latitude');\n% shading interp;\n% hold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\n%\n% figure_w_normalized_uicontrolunits('Name','Std Beta-Value');\n% mData=nan(size(std(params.mB, 'omitnan')));\n% mData=std(params.mB, 'omitnan');\n% pcolor(params.vX,params.vY,...\n% reshape(mData,...\n% size(params.vY,1),size(params.vX,1)));\n% h=colorbar;\n% % set(h,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'std(1-B)')\n% colormap(jet);\n% xlabel('longitude');\n% ylabel('latitude');\n% shading interp;\n% hold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\n\n%\n% figure_w_normalized_uicontrolunits('Name','Beta-probability by cross-comparison');\n% pcolor(params.vX,params.vY,...\n% reshape(calc_ProbColorbar2Value(params.vPcrB),...\n% size(params.vY,1),size(params.vX,1)));\n% plot_ProbColorbar2(cmin, cmax);\n% % set(gca,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'P(B)')\n% xlabel('longitude');\n% ylabel('latitude');\n% shading interp;\n% hold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\n% % colorbar\n\n\nfigure_w_normalized_uicontrolunits('Name','Beta-probability by overlap','Position',[100 25 400 400]);\npcolor(params.vX,params.vY,...\n reshape(calc_ProbColorbar2Value(params.vPolB),...\n size(params.vY,1),size(params.vX,1)));\nplot_ProbColorbar2(cmin, cmax);\n% set(gca,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'P(B)')\nxlabel('longitude');\nylabel('latitude');\nshading interp;\nhold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\nplot_WiemerWyss1994\nxlim([-117.1 -115.6]);\nylim([33 35.2]);\n\nfigure_w_normalized_uicontrolunits('Name','Resolution','Position',[100 25 400 400]);\npcolor(params.vX,params.vY,...\n reshape(params.mSamples_,...\n size(params.vY,1),size(params.vX,1)));\nh=colorbar;\n% set(h,'XAxisLocation','Top','XTick',0.5,'XTickLabel', 'N')\nxlabel('longitude');\nylabel('latitude');\nshading interp;\nhold on;plot(params.mCatalog(:,1),params.mCatalog(:,2),'k.','MarkerSize',0.5);\nplot_WiemerWyss1994\nxlim([-117.1 -115.6]);\nylim([33 35.2]);\n\nend\n\nfunction plot_WiemerWyss1994\nmLatLon=[[-117.1 33];\n [-115.6 33];\n [-115.6 35.2];\n [-117.1 35.2];\n [-117.1 33]];\nhold on;plot(mLatLon(:,1),mLatLon(:,2),'k--');\nmLanders=[-116.4 34.3];\nhold on;plot(mLanders(1),mLanders(2),'ko','MarkerSize',20)\nend\n\n", "meta": {"author": "CelsoReyes", "repo": "zmap7", "sha": "3895fcb3ca3073608abe22ca71960eb082fd0d9a", "save_path": "github-repos/MATLAB/CelsoReyes-zmap7", "path": "github-repos/MATLAB/CelsoReyes-zmap7/zmap7-3895fcb3ca3073608abe22ca71960eb082fd0d9a/zmap_deprecated/orphaned/src/thomas/plot/plot_Maps4.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267762381844, "lm_q2_score": 0.6893056231680121, "lm_q1q2_score": 0.5988871824199167}} {"text": "function judge = TestIfSO3(mat)\n% *** CHAPTER 3: RIGID-BODY MOTIONS ***\n% Takes mat: A 3x3 matrix.\n% Check if mat is close to or on the manifold SO(3).\n% Example Inputs:\n% \n% clear; clc;\n% mat = [1.0, 0.0, 0.0;\n% 0.0, 0.1, -0.95;\n% 0.0, 1.0, 0.1];\n% judge = TestIfSO3(mat)\n% \n% Output:\n% dudge =\n% 0\n\njudge = norm(DistanceToSO3(mat)) < 1e-3;\nend", "meta": {"author": "ShuoYangRobotics", "repo": "QuadrupedSim", "sha": "8427715395b63bddb77329e66f7484e529998445", "save_path": "github-repos/MATLAB/ShuoYangRobotics-QuadrupedSim", "path": "github-repos/MATLAB/ShuoYangRobotics-QuadrupedSim/QuadrupedSim-8427715395b63bddb77329e66f7484e529998445/mr/TestIfSO3.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8688267830311354, "lm_q2_score": 0.6893056167854461, "lm_q1q2_score": 0.5988871815569917}} {"text": "function [lat, lon, gam, k] = utm_inv(zone, northp, x, y)\n%UTM_INV Forward transverse Mercator projection\n%\n% [LAT, LON] = UTM_INV(ZONE, NORTHP, X, Y)\n% [LAT, LON, GAM, K] = UTM_INV(ZONE, NORTHP, X, Y)\n%\n% performs the inverse universal transverse Mercator projection of points\n% (X,Y) to (LAT,LON) using ZONE and NORTHP. X and Y can be scalars or\n% arrays of equal size. ZONE should be an integer in [1,60] and NORTHP\n% is a logical indicating whether the transformation should use the false\n% northing for the northern (NORTHP = true) or southern (NORTHP = false)\n% hemisphere. The forward projection is given by UTM_FWD.\n%\n% GAM and K give metric properties of the projection at (LAT,LON); GAM is\n% the meridian convergence at the point and K is the scale.\n%\n% LAT, LON, GAM are in degrees. The projected coordinates X, Y are in\n% meters. K is dimensionless.\n%\n% This implementation for the UTM projection is based on the series\n% method described in\n%\n% C. F. F. Karney, Transverse Mercator with an accuracy of a few\n% nanometers, J. Geodesy 85(8), 475-485 (Aug. 2011);\n% Addenda: http://geographiclib.sf.net/tm-addenda.html\n%\n% This extends the series given by Krueger (1912) to sixth order in the\n% flattening. This is a substantially better series than that used by\n% the MATLAB mapping toolbox. In particular the errors in the projection\n% are less than 5 nanometers withing 3900 km of the central meridian (and\n% less than 1 mm within 7600 km of the central meridian). The mapping\n% can be continued accurately over the poles to the opposite meridian.\n%\n% This routine depends on the MATLAB File Exchange package \"Geodesics on\n% an ellipsoid of revolution\":\n%\n% http://www.mathworks.com/matlabcentral/fileexchange/39108\n%\n% See also GEODPROJ, UTM_FWD, TRANMERC_INV.\n\n% Copyright (c) Charles Karney (2012) .\n%\n% This file was distributed with GeographicLib 1.29.\n\n if nargin < 4, error('Too few input arguments'), end\n lon0 = -183 + 6 * zone; lat0 = 0;\n fe = 500e3; fn = cvmgt(0, 10000e3, logical(northp)); k0 = 0.9996;\n x = (x - fe) / k0; y = (y - fn) / k0;\n [lat, lon, gam, k] = tranmerc_inv(lat0, lon0, x, y);\n k = k * k0;\nend\n", "meta": {"author": "Sable", "repo": "mcbench-benchmarks", "sha": "ba13b2f0296ef49491b95e3f984c7c41fccdb6d8", "save_path": "github-repos/MATLAB/Sable-mcbench-benchmarks", "path": "github-repos/MATLAB/Sable-mcbench-benchmarks/mcbench-benchmarks-ba13b2f0296ef49491b95e3f984c7c41fccdb6d8/39366-geodesic-projections-for-an-ellipsoid/geographiclib-matlab/utm_inv.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267762381844, "lm_q2_score": 0.689305616785446, "lm_q1q2_score": 0.5988871768745724}} {"text": "function D = driving_function_mono_nfchoa_ps(x0,xs,f,N,conf)\n%DRIVING_FUNCTION_MONO_NFCHOA_PS driving signal for a point source in NFC-HOA\n%\n% Usage: D = driving_function_mono_nfchoa_ps(x0,xs,f,N,conf)\n%\n% Input parameters:\n% x0 - position of the secondary sources / m [nx3]\n% xs - position of virtual point source / m [nx3]\n% f - frequency of the monochromatic source / Hz\n% N - maximum order of spherical harmonics\n% conf - configuration struct (see SFS_config)\n%\n% Output parameters:\n% D - driving function signal [nx1]\n%\n% See also: driving_function_mono_nfchoa, driving_function_imp_nfchoa_ps\n\n%*****************************************************************************\n% The MIT License (MIT) *\n% *\n% Copyright (c) 2010-2019 SFS Toolbox Developers *\n% *\n% Permission is hereby granted, free of charge, to any person obtaining a *\n% copy of this software and associated documentation files (the \"Software\"), *\n% to deal in the Software without restriction, including without limitation *\n% the rights to use, copy, modify, merge, publish, distribute, sublicense, *\n% and/or sell copies of the Software, and to permit persons to whom the *\n% Software is furnished to do so, subject to the following conditions: *\n% *\n% The above copyright notice and this permission notice shall be included in *\n% all copies or substantial portions of the Software. *\n% *\n% THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR *\n% IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, *\n% FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL *\n% THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER *\n% LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING *\n% FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER *\n% DEALINGS IN THE SOFTWARE. *\n% *\n% The SFS Toolbox allows to simulate and investigate sound field synthesis *\n% methods like wave field synthesis or higher order ambisonics. *\n% *\n% https://sfs.readthedocs.io sfstoolbox@gmail.com *\n%*****************************************************************************\n\n\n%% ===== Checking of input parameters ==================================\nnargmin = 5;\nnargmax = 5;\nnarginchk(nargmin,nargmax);\nisargmatrix(x0,xs);\nisargpositivescalar(f,N);\nisargstruct(conf);\n\n\n%% ===== Configuration ==================================================\nxref = conf.xref;\nc = conf.c;\ndimension = conf.dimension;\ndriving_functions = conf.driving_functions;\nX0 = conf.secondary_sources.center;\n\n\n%% ===== Computation ====================================================\n\n% Secondary source positions\nx00 = bsxfun(@minus,x0,X0);\n[phi0,theta0,r0] = cart2sph(x00(:,1),x00(:,2),x00(:,3));\n\n% Point source\nxs0 = bsxfun(@minus,xs,X0);\n[phi,theta,r] = cart2sph(xs0(:,1),xs0(:,2),xs0(:,3));\n\n% Wavenumber\nomega = 2*pi*f;\n\n% modal window\nwin = modal_weighting(N,conf);\n\n% Initialize empty driving signal\nD = zeros(size(x0,1),1);\n\nif strcmp('2D',dimension)\n\n % === 2-Dimensional ==================================================\n\n switch driving_functions\n case 'default'\n % --- SFS Toolbox ------------------------------------------------\n to_be_implemented;\n otherwise\n error(['%s: %s, this type of driving function is not implemented ', ...\n 'for a 2D point source.'],upper(mfilename),driving_functions);\n end\n\n\nelseif strcmp('2.5D',dimension)\n\n % === 2.5-Dimensional ================================================\n\n % Reference point\n xref = repmat(xref,[size(x0,1) 1]);\n\n switch driving_functions\n case 'default'\n % --- SFS Toolbox ------------------------------------------------\n % 2.5D point source\n %\n % _N_ (2)\n % 1 \\ h|m|(w/c r)\n % D(phi0,w) = ------ /__ ------------- e^(i m (phi0-phi))\n % 2pi r0 m=-N (2)\n % h|m|(w/c r0)\n %\n % https://sfs.rtfd.io/en/3.2/d_nfchoa/#equation-fd-nfchoa-point-25d\n for m=-N:N\n D = D + 1 ./ (2.*pi.*r0) ...\n .* win(abs(m)+1) ...\n .* sphbesselh(abs(m),2,omega./c.*r) ...\n ./ sphbesselh(abs(m),2,omega./c.*r0) ...\n .* exp(1i.*m.*(phi0-phi));\n end\n otherwise\n error(['%s: %s, this type of driving function is not implemented ', ...\n 'for a 2.5D point source.'],upper(mfilename),driving_functions);\n end\n\n\nelseif strcmp('3D',dimension)\n\n % === 3-Dimensional ==================================================\n\n switch driving_functions\n case 'default'\n % --- SFS Toolbox ------------------------------------------------\n % 3D point source\n %\n % _N_ _n_ (2)\n % 1 \\ \\ hn(w/c r) -m\n % D(theta0,phi0,w) = ------- /__ /__ ----------- Yn(theta,phi) ...\n % 2pi r0^2 n=0 m=-n (2)\n % hn(w/c r0)\n % m\n % x Yn(theta0,phi0)\n %\n % https://sfs.rtfd.io/en/3.2/d_nfchoa/#equation-fd-nfchoa-point-3d\n %\n for n=0:N\n for m=-n:n\n D = D + 1 ./ (2.*pi.*r0.^2) ...\n .* win(n+1) ...\n .* sphbesselh(n,2,omega./c.*r) ...\n ./ sphbesselh(n,2,omega./c.*r0) ...\n .* sphharmonics(n,-m,theta,phi) ...\n .* sphharmonics(n,m,theta0,phi0);\n end\n end\n otherwise\n error(['%s: %s, this type of driving function is not implemented ', ...\n 'for a 3D point source.'],upper(mfilename),driving_functions);\n end\n\nelse\n error('%s: the dimension %s is unknown.',upper(mfilename),dimension);\nend\n", "meta": {"author": "sfstoolbox", "repo": "sfs-matlab", "sha": "02194f0243d1ead26572f760032c40527718919d", "save_path": "github-repos/MATLAB/sfstoolbox-sfs-matlab", "path": "github-repos/MATLAB/sfstoolbox-sfs-matlab/sfs-matlab-02194f0243d1ead26572f760032c40527718919d/SFS_monochromatic/driving_functions_mono/driving_function_mono_nfchoa_ps.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES\n\n", "lm_q1_score": 0.8688267660487572, "lm_q2_score": 0.6893056231680121, "lm_q1q2_score": 0.5988871753962872}} {"text": "%\n% A variational approach to SPCP (Aravkin et al. 2014)\n%\n% RPCA | SPCP-sum-SPG | Stable PCP-sum solved by Spectral Projected Gradient (Aravkin et al. 2014)\n% process_video('RPCA', 'flip-SPCP-sum-SPG', 'dataset/demo.avi', 'output/demo_flip-SPCP-sum-SPG.avi');\n\nalg_path_aux = fullfile(lrs_conf.rpca_path,'SPGL1');\naddpath(genpath(alg_path_aux));\n\nnFrames = size(M,2);\nlambda = 1/sqrt(max(size(M,1),size(M,2)));\nL0 = repmat(median(M,2), 1, nFrames);\nS0 = M - L0;\nepsilon = 5e-3*norm(M,'fro'); % tolerance for fidelity to data\n\n% Flip-Flop version of SPCP-sum solved by Spectral Projected Gradient\nopts = struct('sum',true,'L0',L0,'S0',S0,'max',false,...\n 'tau0',3e5,'SPGL1_tol',1e-1,'tol',1e-3);\n[L,S] = solver_RPCA_SPGL1(M,lambda,epsilon,[],opts);\n\nrmpath(genpath(alg_path_aux));", "meta": {"author": "andrewssobral", "repo": "lrslibrary", "sha": "06d457349cb5f1fc56a583cd61af9f1d5150e3a1", "save_path": "github-repos/MATLAB/andrewssobral-lrslibrary", "path": "github-repos/MATLAB/andrewssobral-lrslibrary/lrslibrary-06d457349cb5f1fc56a583cd61af9f1d5150e3a1/algorithms/rpca/flip-SPCP-sum-SPG/run_alg.m", "lm_name": "Qwen/Qwen-72B", "lm_label": "1. YES\n2. YES", "lm_q1_score": 0.8688267626522814, "lm_q2_score": 0.6893056104028799, "lm_q1q2_score": 0.5988871619643888}} {"text": "classdef CommunityDetection < PROBLEM\n%