diff options
| author | ziejd2 | 2017-09-28 15:04:40 -0500 |
|---|---|---|
| committer | ziejd2 | 2017-09-28 15:04:40 -0500 |
| commit | 8070dc963753142bb86c4ed698d91fd623ed28e7 (patch) | |
| tree | d0f6dd8fc46a49b819aa55c1a90faa14d8448883 /sourcecodes/bnt-master/KPMtools | |
| parent | 7cc31810d53176e805532b2789955f4eedbce6bb (diff) | |
| download | BNW-8070dc963753142bb86c4ed698d91fd623ed28e7.tar.gz | |
BNW using Octave instead of Matlab.
This version of BNW should perform the same as the original version. The only difference is that it uses Octave instead of Matlab when running BayesNet Toolbox during parameter learning. I am calling this BNW_1.02. It can be accessed at: compbio.uthsc.edu/BNW_1.02
Diffstat (limited to 'sourcecodes/bnt-master/KPMtools')
183 files changed, 8805 insertions, 0 deletions
diff --git a/sourcecodes/bnt-master/KPMtools/CVS/Entries b/sourcecodes/bnt-master/KPMtools/CVS/Entries new file mode 100644 index 00000000..041ea399 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/CVS/Entries @@ -0,0 +1,176 @@ +/README.txt/1.1.1.1/Tue Apr 26 02:30:30 2005// +/approx_unique.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/approxeq.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/argmax.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/argmin.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/asdemo.html/1.1.1.1/Wed Mar 30 19:59:00 2005// +/asdemo.m/1.1.1.1/Sun Mar 27 02:51:24 2005// +/asort.m/1.1.1.1/Fri May 13 20:52:22 2005// +/assert.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/assignEdgeNums.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/assign_cols.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/axis_pct.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/bipartiteMatchingDemo.m/1.1.1.1/Mon May 9 16:47:32 2005// +/bipartiteMatchingDemoPlot.m/1.1.1.1/Mon May 9 04:45:10 2005// +/bipartiteMatchingHungarian.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/bipartiteMatchingIntProg.m/1.1.1.1/Mon May 9 05:25:10 2005// +/block.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/cell2matPad.m/1.1.1.1/Tue Jun 28 01:30:44 2005// +/cell2num.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/centeringMatrix.m/1.1.1.1/Sun May 8 22:48:48 2005// +/checkpsd.m/1.1.1.1/Fri Feb 7 02:25:30 2003// +/chi2inv.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/choose.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/collapse_mog.m/1.1.1.1/Tue Apr 26 02:30:30 2005// +/colmult.c/1.1.1.1/Tue Apr 26 02:30:30 2005// +/colmult.mexglx/1.1.1.1/Tue Apr 26 02:30:30 2005// +/computeROC.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/compute_counts.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/conf2mahal.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/cross_entropy.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/dirKPM.m/1.1.1.1/Fri May 13 20:52:22 2005// +/div.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/draw_circle.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/draw_ellipse.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/draw_ellipse_axes.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/em_converged.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/entropy.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/exportfig.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/extend_domain_table.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/factorial.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/filepartsLast.m/1.1.1.1/Mon May 30 22:08:06 2005// +/find_equiv_posns.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/fullfileKPM.m/1.1.1.1/Sat Aug 27 01:08:50 2005// +/genpathKPM.m/1.1.1.1/Wed May 25 19:11:42 2005// +/hash_add.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/hash_del.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/hash_lookup.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/hsvKPM.m/1.1.1.1/Mon May 2 20:19:00 2005// +/hungarian.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/image_rgb.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/imresizeAspect.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/ind2subv.c/1.1.1.1/Tue Apr 26 02:30:32 2005// +/ind2subv.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/initFigures.m/1.1.1.1/Wed Jun 1 04:49:22 2005// +/installC_KPMtools.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/is_psd.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/is_stochastic.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/isemptycell.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/isposdef.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/isscalar.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/isvector.m/1.1.1.1/Tue Apr 26 02:30:32 2005// +/junk.c/1.1.1.1/Tue Apr 26 02:30:32 2005// +/loadcell.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/logb.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/logdet.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/logsum.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/logsum_simple.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/logsum_test.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/logsumexp.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/logsumexpv.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mahal2conf.m/1.1.1.1/Wed Apr 27 17:58:32 2005// +/marg_table.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/marginalize_table.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/matprint.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/max_mult.c/1.1.1.1/Tue Apr 26 02:30:34 2005// +/max_mult.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mexutil.c/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mexutil.h/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mk_multi_index.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mk_stochastic.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mkdirKPM.m/1.1.1.1/Mon May 9 22:20:22 2005// +/montageKPM.m/1.1.1.1/Wed Jun 1 19:39:54 2005// +/montageKPM2.m/1.1.1.1/Wed Jul 6 19:32:54 2005// +/montageKPM3.m/1.1.1.1/Tue Jun 28 01:35:44 2005// +/mult_by_table.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myintersect.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myismember.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myones.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myplot.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myrand.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myrepmat.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myreshape.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mysetdiff.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mysize.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mysubset.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/mysymsetdiff.m/1.1.1.1/Tue Apr 26 02:30:34 2005// +/myunion.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/nchoose2.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/ncols.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/nonmaxsup.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/normalise.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/normaliseC.c/1.1.1.1/Tue Apr 26 02:30:36 2005// +/normaliseC.dll/1.1.1.1/Tue Apr 26 02:30:36 2005// +/normalize.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/nrows.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/num2strcell.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/optimalMatching.m/1.1.1.1/Mon May 9 22:20:22 2005// +/optimalMatchingTest.m/1.1.1.1/Mon May 9 22:20:22 2005// +/partitionData.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/partition_matrix_vec.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/pca_kpm.m/1.1.1.1/Tue Sep 13 05:18:28 2005// +/pca_netlab.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/pick.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plotBox.m/1.1.1.1/Mon May 30 06:01:56 2005// +/plotColors.m/1.1.1.1/Thu May 26 01:31:22 2005// +/plotROC.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plotROCkpm.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plot_axis_thru_origin.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plot_ellipse.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plot_matrix.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plot_polygon.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plotcov2.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plotcov2New.m/1.1.1.1/Mon Jul 11 19:07:28 2005// +/plotcov3.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plotgauss1d.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plotgauss2d.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/plotgauss2d_old.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/polygon_area.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/polygon_centroid.m/1.1.1.1/Tue Apr 26 02:30:36 2005// +/polygon_intersect.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/previewfig.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/process_options.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rand_psd.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rectintC.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rectintLoopC.c/1.1.1.1/Sun Jun 5 18:46:40 2005// +/rectintLoopC.dll/1.1.1.1/Sun Jun 5 18:46:40 2005// +/rectintLoopC.mexglx/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rectintSparse.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rectintSparseC.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rectintSparseLoopC.c/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rectintSparseLoopC.dll/1.1.1.1/Tue Apr 26 02:30:38 2005// +/repmatC.c/1.1.1.1/Tue Apr 26 02:30:38 2005// +/repmatC.dll/1.1.1.1/Tue Apr 26 02:30:38 2005// +/repmatC.mexglx/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rgb2grayKPM.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rnd_partition.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/rotate_xlabel.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/safeStr.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/sampleUniformInts.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/sample_discrete.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/set_xtick_label.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/set_xtick_label_demo.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/setdiag.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/softeye.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/sort_evec.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/splitLongSeqIntoManyShort.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/sprintf_intvec.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/sqdist.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/strmatch_multi.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/strmatch_substr.m/1.1.1.1/Tue Apr 26 02:30:38 2005// +/strsplit.m/1.1.1.1/Tue May 3 19:01:46 2005// +/subplot2.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/subplot3.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/subsets.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/subsets1.m/1.1.1.1/Mon May 9 22:20:22 2005// +/subsetsFixedSize.m/1.1.1.1/Mon May 9 02:55:36 2005// +/subv2ind.c/1.1.1.1/Tue Apr 26 02:30:40 2005// +/subv2ind.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/sumv.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/suptitle.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/unaryEncoding.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/wrap.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/xticklabel_rotate90.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/zipload.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +/zipsave.m/1.1.1.1/Tue Apr 26 02:30:40 2005// +D diff --git a/sourcecodes/bnt-master/KPMtools/CVS/Repository b/sourcecodes/bnt-master/KPMtools/CVS/Repository new file mode 100644 index 00000000..0b5b553e --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/CVS/Repository @@ -0,0 +1 @@ +FullBNT/KPMtools diff --git a/sourcecodes/bnt-master/KPMtools/CVS/Root b/sourcecodes/bnt-master/KPMtools/CVS/Root new file mode 100644 index 00000000..f3bd14a6 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/CVS/Root @@ -0,0 +1 @@ +:ext:nsaunier@bnt.cvs.sourceforge.net:/cvsroot/bnt diff --git a/sourcecodes/bnt-master/KPMtools/README.txt b/sourcecodes/bnt-master/KPMtools/README.txt new file mode 100644 index 00000000..fff044b0 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/README.txt @@ -0,0 +1,3 @@ +KPMtools is a directory of miscellaneous matlab functions written by +Kevin Patrick Murphy and various other people (see individual file headers). + diff --git a/sourcecodes/bnt-master/KPMtools/approx_unique.m b/sourcecodes/bnt-master/KPMtools/approx_unique.m new file mode 100644 index 00000000..adb5bd07 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/approx_unique.m @@ -0,0 +1,41 @@ +function [B, keep] = approx_unique(A, thresh, flag) +% APPROX_UNIQUE Return elements of A that differ from the rest by less than thresh +% B = approx_unique(A, thresh) +% B = approx_unique(A, thresh, 'rows') + +keep = []; + +if nargin < 3 | isempty(flag) + A = sort(A) + B = A(1); + for i=2:length(A) + if ~approxeq(A(i), A(i-1), thresh) + B = [B A(i)]; + keep = [keep i]; + end + end +else +% A = sortrows(A); +% B = A(1,:); +% for i=2:size(A,1) +% if ~approxeq(A(i,:), A(i-1,:), thresh) +% B = [B; A(i,:)]; +% keep = [keep i]; +% end +% end + B = []; + for i=1:size(A,1) + duplicate = 0; + for j=i+1:size(A,1) + if approxeq(A(i,:), A(j,:), thresh) + duplicate = 1; + break; + end + end + if ~duplicate + B = [B; A(i,:)]; + keep = [keep i]; + end + end +end + diff --git a/sourcecodes/bnt-master/KPMtools/approxeq.m b/sourcecodes/bnt-master/KPMtools/approxeq.m new file mode 100644 index 00000000..559efc5e --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/approxeq.m @@ -0,0 +1,21 @@ +function p = approxeq(a, b, tol, rel) +% APPROXEQ Are a and b approximately equal (to within a specified tolerance)? +% p = approxeq(a, b, thresh) +% 'tol' defaults to 1e-3. +% p(i) = 1 iff abs(a(i) - b(i)) < thresh +% +% p = approxeq(a, b, thresh, 1) +% p(i) = 1 iff abs(a(i)-b(i))/abs(a(i)) < thresh + +if nargin < 3, tol = 1e-2; end +if nargin < 4, rel = 0; end + +a = a(:); +b = b(:); +d = abs(a-b); +if rel + p = ~any( (d ./ (abs(a)+eps)) > tol); +else + p = ~any(d > tol); +end + diff --git a/sourcecodes/bnt-master/KPMtools/argmax.m b/sourcecodes/bnt-master/KPMtools/argmax.m new file mode 100644 index 00000000..1dcc1ecf --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/argmax.m @@ -0,0 +1,11 @@ +function indices = argmax(v) +% ARGMAX Return as a subscript vector the location of the largest element of a multidimensional array v. +% indices = argmax(v) +% +% Returns the first maximum in the case of ties. +% Example: +% X = [2 8 4; 7 3 9]; +% argmax(X) = [2 3], i.e., row 2 column 3 + +[m i] = max(v(:)); +indices = ind2subv(mysize(v), i); diff --git a/sourcecodes/bnt-master/KPMtools/argmin.m b/sourcecodes/bnt-master/KPMtools/argmin.m new file mode 100644 index 00000000..74dc276f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/argmin.m @@ -0,0 +1,12 @@ +function indices = argmin(v) +% ARGMIN Return as a subscript vector the location of the smallest element of a multidimensional array v. +% indices = argmin(v) +% +% Returns the first minimum in the case of ties. +% Example: +% X = [2 8 4; 7 3 9]; +% argmin(X) = [1 1], i.e., row 1 column 1 + +[m i] = min(v(:)); +indices = ind2subv(mysize(v), i); +%indices = ind2subv(size(v), i); diff --git a/sourcecodes/bnt-master/KPMtools/asdemo.html b/sourcecodes/bnt-master/KPMtools/asdemo.html new file mode 100644 index 00000000..f77c8660 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/asdemo.html @@ -0,0 +1,690 @@ +<html xmlns:v="urn:schemas-microsoft-com:vml" +xmlns:o="urn:schemas-microsoft-com:office:office" +xmlns:w="urn:schemas-microsoft-com:office:word" +xmlns:st1="urn:schemas-microsoft-com:office:smarttags" +xmlns:mwsh="http://www.mathworks.com/namespace/mcode/v1/syntaxhighlight.dtd" +xmlns="http://www.w3.org/TR/REC-html40"> + +<head> +<meta http-equiv=Content-Type content="text/html; charset=utf-8"> +<meta name=ProgId content=Word.Document> +<meta name=Generator content="Microsoft Word 10"> +<meta name=Originator content="Microsoft Word 10"> +<link rel=File-List href="asdemo_files/filelist.xml"> +<title>asdemo</title> +<o:SmartTagType namespaceuri="urn:schemas-microsoft-com:office:smarttags" + name="time"/> +<o:SmartTagType namespaceuri="urn:schemas-microsoft-com:office:smarttags" + name="date"/> +<o:SmartTagType namespaceuri="urn:schemas-microsoft-com:office:smarttags" + name="place"/> +<!--[if gte mso 9]><xml> + <o:DocumentProperties> + <o:Author>Caroline Schwarz</o:Author> + <o:Template>Normal</o:Template> + <o:LastAuthor>us</o:LastAuthor> + <o:Revision>33</o:Revision> + <o:TotalTime>0</o:TotalTime> + <o:Created>2005-03-26T16:20:00Z</o:Created> + <o:LastSaved>2005-03-30T09:58:00Z</o:LastSaved> + <o:Pages>1</o:Pages> + <o:Words>1062</o:Words> + <o:Characters>6055</o:Characters> + <o:Company>office</o:Company> + <o:Lines>50</o:Lines> + <o:Paragraphs>14</o:Paragraphs> + <o:CharactersWithSpaces>7103</o:CharactersWithSpaces> + <o:Version>10.3501</o:Version> + </o:DocumentProperties> + <o:OfficeDocumentSettings> + <o:RelyOnVML/> + <o:AllowPNG/> + <o:TargetScreenSize>1280x1024</o:TargetScreenSize> + </o:OfficeDocumentSettings> +</xml><![endif]--><!--[if gte mso 9]><xml> + <w:WordDocument> + <w:SpellingState>Clean</w:SpellingState> + <w:GrammarState>Clean</w:GrammarState> + <w:Compatibility> + <w:UseFELayout/> + </w:Compatibility> + <w:BrowserLevel>MicrosoftInternetExplorer4</w:BrowserLevel> + </w:WordDocument> +</xml><![endif]--><!--[if !mso]><object + classid="clsid:38481807-CA0E-42D2-BF39-B33AF135CC4D" id=ieooui></object> +<style> +st1\:*{behavior:url(#ieooui) } +</style> +<![endif]--> +<style> +<!--p + {max-width: 600px; + width:expression(document.body.clientWidth > 620 ? "600px": "auto" );} +h1 + {max-width: 600px; + width:expression(document.body.clientWidth > 620 ? "600px": "auto" );} +h2 + {max-width: 600px; + width:expression(document.body.clientWidth > 620 ? "600px": "auto" );} +div + {max-width: 600px; + width:expression(document.body.clientWidth > 620 ? "600px": "auto" );} + + /* Font Definitions */ + @font-face + {font-family:"MS Mincho"; + panose-1:2 2 6 9 4 2 5 8 3 4; + mso-font-alt:"ï¼ï¼³ 明æœ"; + mso-font-charset:128; + mso-generic-font-family:modern; + mso-font-pitch:fixed; + mso-font-signature:-1610612033 1757936891 16 0 131231 0;} +@font-face + {font-family:"\@MS Mincho"; + panose-1:2 2 6 9 4 2 5 8 3 4; + mso-font-charset:128; + mso-generic-font-family:modern; + mso-font-pitch:fixed; + mso-font-signature:-1610612033 1757936891 16 0 131231 0;} + /* Style Definitions */ + p.MsoNormal, li.MsoNormal, div.MsoNormal + {mso-style-parent:""; + margin:0cm; + margin-bottom:.0001pt; + mso-pagination:widow-orphan; + font-size:10.0pt; + font-family:Arial; + mso-fareast-font-family:"Times New Roman"; + mso-believe-normal-left:yes;} +h1 + {mso-margin-top-alt:auto; + margin-right:0cm; + mso-margin-bottom-alt:auto; + margin-left:0cm; + mso-pagination:widow-orphan; + mso-outline-level:1; + font-size:24.0pt; + font-family:Arial; + mso-fareast-font-family:"MS Mincho"; + color:#990000; + font-weight:bold;} +h2 + {mso-margin-top-alt:auto; + margin-right:0cm; + mso-margin-bottom-alt:auto; + margin-left:0cm; + mso-pagination:widow-orphan; + mso-outline-level:2; + font-size:13.5pt; + font-family:Arial; + mso-fareast-font-family:"MS Mincho"; + color:#990000; + font-weight:bold;} +p + {mso-margin-top-alt:auto; + margin-right:0cm; + mso-margin-bottom-alt:auto; + margin-left:0cm; + mso-pagination:widow-orphan; + font-size:10.0pt; + font-family:Arial; + mso-fareast-font-family:"Times New Roman";} +pre + {margin:0cm; + margin-bottom:.0001pt; + mso-pagination:widow-orphan; + tab-stops:45.8pt 91.6pt 137.4pt 183.2pt 229.0pt 274.8pt 320.6pt 366.4pt 412.2pt 458.0pt 503.8pt 549.6pt 595.4pt 641.2pt 687.0pt 732.8pt; + font-size:10.0pt; + font-family:"Courier New"; + mso-fareast-font-family:"Times New Roman";} +p.footer, li.footer, div.footer + {mso-style-name:footer; + mso-margin-top-alt:auto; + margin-right:0cm; + mso-margin-bottom-alt:auto; + margin-left:0cm; + text-align:right; + mso-pagination:widow-orphan; + font-size:7.5pt; + font-family:Arial; + mso-fareast-font-family:"Times New Roman"; + color:gray; + font-style:italic;} +span.keyword + {mso-style-name:keyword; + color:blue;} +span.comment + {mso-style-name:comment; + color:forestgreen;} +span.string + {mso-style-name:string; + color:#A020F0;} +span.untermstring + {mso-style-name:untermstring; + color:#B20000;} +span.syscmd + {mso-style-name:syscmd; + color:#B28C00;} +span.SpellE + {mso-style-name:""; + mso-spl-e:yes;} +span.GramE + {mso-style-name:""; + mso-gram-e:yes;} +@page Section1 + {size:612.0pt 792.0pt; + margin:72.0pt 90.0pt 72.0pt 90.0pt; + mso-header-margin:36.0pt; + mso-footer-margin:36.0pt; + mso-paper-source:0;} +div.Section1 + {page:Section1;} +--> +</style> +<!--[if gte mso 10]> +<style> + /* Style Definitions */ + table.MsoNormalTable + {mso-style-name:"Table Normal"; + mso-tstyle-rowband-size:0; + mso-tstyle-colband-size:0; + mso-style-noshow:yes; + mso-style-parent:""; + mso-padding-alt:0cm 5.4pt 0cm 5.4pt; + mso-para-margin:0cm; + mso-para-margin-bottom:.0001pt; + mso-pagination:widow-orphan; + font-size:10.0pt; + font-family:"Times New Roman";} +</style> +<![endif]--><![if mso 9]> +<style> +p.MsoNormal + {margin-left:7.5pt;} +</style> +<![endif]><!-- +This HTML is auto-generated from an M-file. +To make changes, update the M-file and republish this document. + --> +<meta name=date content=2005-03-26> +<meta name=m-file content=asdemo> +<!--[if gte mso 9]><xml> + <o:shapedefaults v:ext="edit" spidmax="5122"/> +</xml><![endif]--><!--[if gte mso 9]><xml> + <o:shapelayout v:ext="edit"> + <o:idmap v:ext="edit" data="1"/> + </o:shapelayout></xml><![endif]--> +</head> + +<body bgcolor=white lang=EN-US style='tab-interval:36.0pt;margin-left:7.5pt; +margin-top:7.5pt;margin-right:7.5pt;margin-bottom:7.5pt'> + +<div class=Section1><pre style='margin-left:22.5pt'><span class=comment>% <b +style='mso-bidi-font-weight:normal'>ASORT</b></span></pre><pre +style='margin-left:22.5pt'><span class=comment>% a pedestrian <b +style='mso-bidi-font-weight:normal'>NUMERICAL SORTER</b> of <b +style='mso-bidi-font-weight:normal'>ALPHANUMERIC</b> data</span></pre><pre +style='margin-left:22.5pt'><o:p> </o:p></pre><pre style='margin-left:22.5pt'><span +class=comment>% - create some data</span></pre><pre style='margin-left:22.5pt'><b +style='mso-bidi-font-weight:normal'><span style='mso-tab-count:2'>         </span>d = {<o:p></o:p></b></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-tab-count: +2'>        </span>strings with one valid alphanumeric number</span></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-tab-count: +2'>        </span>sorted <b style='mso-bidi-font-weight:normal'>numerically</b></span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'-<span class=SpellE><span class=GramE>inf</span></span>'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'<span class=GramE>x-3.2e4y</span>'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'<span class=GramE>f-1.4</span>'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'-.1'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'+ <span +class=GramE>.1d-2</span>'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'.1'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'f.1'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'f -+1.4'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'f.2'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'f.3'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'f.10'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'f.11'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'+<span class=SpellE>inf</span>'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=GramE><span class=string>' -</span></span><span class=SpellE><span +class=string>nan</span></span><span class=string>'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'+ <span class=SpellE><span class=GramE>nan</span></span>'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'<span class=SpellE><span class=GramE>nan</span></span>'</span></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-tab-count: +2'>        </span>strings with many numbers or invalid/ambiguous numbers</span></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-tab-count: +2'>        </span>sorted in <span class=SpellE><span class=GramE><b +style='mso-bidi-font-weight:normal'>ascii</b></span></span><b style='mso-bidi-font-weight: +normal'> dictionary order</b></span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=GramE><span +class=string>' <span class=SpellE>nan</span></span></span><span class=string> <span +class=SpellE>nan</span>'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'+ .1e-.2'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'-1 2'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'Z12e12ez'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'<span class=SpellE><span class=GramE>inf</span></span> -<span +class=SpellE>inf</span>'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'s.3TT.4'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'z12e12ez'</span></pre><pre style='margin-left:22.5pt'><span +class=comment>%<span style='mso-tab-count:2'>        </span>strings without numbers</span></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-tab-count: +2'>        </span>sorted in <span class=SpellE><span class=GramE><b +style='mso-bidi-font-weight:normal'>ascii</b></span></span><b style='mso-bidi-font-weight: +normal'> dictionary order</b></span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>' . .. '</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'.'</span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:3'>                 </span><span class=string>'...'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=GramE><span class=string>'.b a.'</span></span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'<span class=GramE>a</span> string'</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:3'>                 </span><span +class=string>'a. .b'</span></pre><pre style='margin-left:22.5pt'><b +style='mso-bidi-font-weight:normal'><span style='mso-tab-count:2'>         </span>};<o:p></o:p></b></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-spacerun:yes'>  </span>... and scramble it...</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span><span +class=GramE>rand(</span><span class=string>'seed'</span>,10);</pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span>d=<span +class=GramE>d(</span><span class=SpellE>randperm</span>(<span class=SpellE>numel</span>(d)));</pre><pre +style='margin-left:22.5pt'><o:p> </o:p></pre><pre style='margin-left:22.5pt'><span +class=comment>% - run <b style='mso-bidi-font-weight:normal'>ASORT</b> with<o:p></o:p></span></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-spacerun:yes'>  </span><b +style='mso-bidi-font-weight:normal'>verbose output</b>:<span style='mso-tab-count: +2'>             </span><-v></span></pre><pre style='margin-left:22.5pt'><span +class=comment>%<span style='mso-spacerun:yes'>  </span><span class=GramE><b +style='mso-bidi-font-weight:normal'>keep</b></span><b style='mso-bidi-font-weight: +normal'> additional results</b>:<span style='mso-tab-count:1'>    </span><-d></span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span>o=<span +class=SpellE><span class=GramE>asort</span></span><span class=GramE>(</span>d,<span +class=string>'-v'</span>,<span class=string>'-d'</span>);</pre><pre +style='margin-left:22.5pt'><span class=comment>% - or</span></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-tab-count: +2'>        </span>p=<span class=SpellE><span class=GramE>asort</span></span><span +class=GramE>(</span>char(d),</span><span class=string>'-v'</span>,<span +class=string>'-d'</span>);</pre><pre style='margin-left:7.5pt'><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'INPUT'<span style='mso-spacerun:yes'>      </span>'ASCII SORT'<span style='mso-spacerun:yes'>   </span>'NUM SORT'<span style='mso-spacerun:yes'>            </span>'NUM READ'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'...'<span style='mso-spacerun:yes'>        </span><span +class=SpellE><span class=GramE>'</span></span><span class=GramE> -</span><span +class=SpellE>nan</span>'<span style='mso-spacerun:yes'>        </span>'--- NUMERICAL'<span style='mso-spacerun:yes'>       </span>'--- NUMBERS'<span style='mso-spacerun:yes'>     </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'+ .1e-.2'<span style='mso-spacerun:yes'>   </span><span +class=GramE>' .</span> .. '<span style='mso-spacerun:yes'>       </span>'-<span +class=SpellE><span class=GramE>inf</span></span>'<span style='mso-spacerun:yes'>        </span><span style='mso-spacerun:yes'>        </span>[<span style='mso-spacerun:yes'>            </span>-<span +class=SpellE>Inf</span>]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'.1'<span style='mso-spacerun:yes'>         </span>' <span +class=SpellE>nan</span> <span class=SpellE>nan</span>'<span style='mso-spacerun:yes'>     </span>'x-3.2e4y'<span style='mso-spacerun:yes'>            </span>[<span style='mso-spacerun:yes'>          </span>-32000]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'.b a.'<span style='mso-spacerun:yes'>      </span>'+ .1d-2'<span style='mso-spacerun:yes'>      </span>'f-1.4'<span style='mso-spacerun:yes'>               </span>[<span style='mso-spacerun:yes'>            </span>-1.4]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'-<span +class=SpellE>inf</span>'<span style='mso-spacerun:yes'>       </span>'+ .1e-.2'<span style='mso-spacerun:yes'>     </span>'-.1'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>            </span>-0.1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f.1'<span style='mso-spacerun:yes'>        </span>'+ <span +class=SpellE><span class=GramE>nan</span></span>'<span style='mso-spacerun:yes'>        </span>'+ .1d-2'<span style='mso-spacerun:yes'>             </span>[<span style='mso-spacerun:yes'>           </span>0.001]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span class=GramE>' -</span><span +class=SpellE>nan</span>'<span style='mso-spacerun:yes'>      </span>'+<span +class=SpellE>inf</span>'<span style='mso-spacerun:yes'>         </span>'.1'<span style='mso-spacerun:yes'>                  </span>[<span style='mso-spacerun:yes'>             </span>0.1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'-1 2'<span style='mso-spacerun:yes'>       </span>'-.1'<span style='mso-spacerun:yes'>          </span>'f.1'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>               </span>1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'<span +class=SpellE><span class=GramE>nan</span></span>'<span style='mso-spacerun:yes'>        </span>'-1 2'<span style='mso-spacerun:yes'>         </span>'f -+1.4'<span style='mso-spacerun:yes'>             </span>[<span style='mso-spacerun:yes'>             </span>1.4]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'<span +class=GramE>a</span> string'<span style='mso-spacerun:yes'>   </span>'-<span +class=SpellE>inf</span>'<span style='mso-spacerun:yes'>         </span>'f.2'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>               </span>2]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span class=GramE>'f.3'<span style='mso-spacerun:yes'>        </span>'.'</span><span style='mso-spacerun:yes'>            </span>'f.3'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>               </span>3]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'+ <span +class=GramE>.1d-2</span>'<span style='mso-spacerun:yes'>    </span>'...'<span style='mso-spacerun:yes'>          </span>'f.10'<span style='mso-spacerun:yes'>  </span><span style='mso-spacerun:yes'>              </span>[<span style='mso-spacerun:yes'>              </span>10]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'a. .b'<span style='mso-spacerun:yes'>      </span>'.1'<span style='mso-spacerun:yes'>           </span>'f.11'<span style='mso-spacerun:yes'>                </span>[<span style='mso-spacerun:yes'>    </span><span style='mso-spacerun:yes'>          </span>11]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'s.3TT.4'<span style='mso-spacerun:yes'>    </span>'.b a.'<span style='mso-spacerun:yes'>    </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>   </span>'+<span +class=SpellE>inf</span>'<span style='mso-spacerun:yes'>                </span>[<span style='mso-spacerun:yes'>             </span><span +class=SpellE><span class=GramE>Inf</span></span>]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span>'+<span +class=SpellE>inf</span>'<span style='mso-spacerun:yes'>       </span>'Z12e12ez'<span style='mso-spacerun:yes'>     </span>' -<span +class=SpellE>nan</span>'<span style='mso-spacerun:yes'>               </span>[<span style='mso-spacerun:yes'>         </span><span style='mso-spacerun:yes'>    </span></span></i><st1:place><span + class=SpellE><i><span style='color:gray'>NaN</span></i></span></st1:place><i><span +style='color:gray'>]<o:p></o:p></span></i></pre><pre><i><span style='color: +gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>nan</span></span> <span class=SpellE>nan</span>'<span style='mso-spacerun:yes'>   </span>'a string'<span style='mso-spacerun:yes'>     </span>'+ <span +class=SpellE>nan</span>'<span style='mso-spacerun:yes'>               </span>[<span style='mso-spacerun:yes'>             </span></span></i><st1:place><span + class=SpellE><i><span style='color:gray'>NaN</span></i></span></st1:place><i><span +style='color:gray'>]<o:p></o:p></span></i></pre><pre><i><span style='color: +gray'><span style='mso-spacerun:yes'>   </span>'<span class=GramE>f-1.4</span>'<span style='mso-spacerun:yes'>      </span>'a. .<span +class=GramE>b</span>'<span style='mso-spacerun:yes'>   </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>    </span>'<span +class=SpellE>nan</span>'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>             </span></span></i><st1:place><span + class=SpellE><i><span style='color:gray'>NaN</span></i></span></st1:place><i><span +style='color:gray'>]<o:p></o:p></span></i></pre><pre><i><span style='color: +gray'><span style='mso-spacerun:yes'>   </span>'x-3.2e4y'<span style='mso-spacerun:yes'>   </span>'f -+1.4'<span style='mso-spacerun:yes'>    </span><span style='mso-spacerun:yes'>  </span>'--- ASCII NUMBERS'<span style='mso-spacerun:yes'>   </span>'--- ASCII NUMBERS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'<span +class=SpellE><span class=GramE>inf</span></span> -<span class=SpellE>inf</span>'<span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>  </span>'f-1.4'<span style='mso-spacerun:yes'>        </span>' <span +class=SpellE>nan</span> <span class=SpellE>nan</span>'<span style='mso-spacerun:yes'>            </span>' <span +class=SpellE>nan</span> <span class=SpellE>nan</span>'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'+ <span +class=SpellE><span class=GramE>nan</span></span>'<span style='mso-spacerun:yes'>      </span>'f.1'<span style='mso-spacerun:yes'>          </span>'+ .1e-.2'<span style='mso-spacerun:yes'>            </span>'+ .1e-.2'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'f.2'<span style='mso-spacerun:yes'>        </span>'f.10'<span style='mso-spacerun:yes'>         </span>'-1 2'<span style='mso-spacerun:yes'>                </span>'-1 2'<span style='mso-spacerun:yes'>            </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'f.11'<span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE>'f.11'</span><span style='mso-spacerun:yes'>         </span>'Z12e12ez'<span style='mso-spacerun:yes'>            </span><span +class=SpellE>'Z12e12ez'</span><span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'Z12e12ez'<span style='mso-spacerun:yes'>   </span>'f.2'<span style='mso-spacerun:yes'>     </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>    </span>'<span +class=SpellE>inf</span> -<span class=SpellE>inf</span>'<span style='mso-spacerun:yes'>            </span>'<span +class=SpellE>inf</span> -<span class=SpellE>inf</span>'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'z12e12ez'<span style='mso-spacerun:yes'>   </span>'f.3'<span style='mso-spacerun:yes'>          </span>'s.3TT.4'<span style='mso-spacerun:yes'>             </span><span +class=SpellE>'s.3TT.4'</span><span style='mso-spacerun:yes'>         </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'f -+1.4'<span style='mso-spacerun:yes'>    </span>'<span +class=SpellE>inf</span> -<span class=SpellE>inf</span>'<span style='mso-spacerun:yes'>     </span>'z12e12ez'<span style='mso-spacerun:yes'>            </span><span +class=SpellE>'z12e12ez'</span><span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>' . .. '<span style='mso-spacerun:yes'>     </span>'<span +class=SpellE><span class=GramE>nan</span></span>'<span style='mso-spacerun:yes'>          </span>'--- ASCII STRINGS'<span style='mso-spacerun:yes'>   </span>'--- ASCII STRINGS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f.10'<span style='mso-spacerun:yes'>       </span>'s.3TT.4'<span style='mso-spacerun:yes'>      </span><span +class=GramE>' .</span> .. '<span style='mso-spacerun:yes'>        </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE>'</span> . .. '<span style='mso-spacerun:yes'>          </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'.'<span style='mso-spacerun:yes'>          </span><span +class=GramE>'x-3.2e4y'<span style='mso-spacerun:yes'>     </span>'.'</span><span style='mso-spacerun:yes'>                   </span><span +class=SpellE>'.'</span><span style='mso-spacerun:yes'>               </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'-.1'<span style='mso-spacerun:yes'>    </span><span style='mso-spacerun:yes'>    </span>'z12e12ez'<span style='mso-spacerun:yes'>     </span>'...'<span style='mso-spacerun:yes'>                 </span><span +class=SpellE>'</span>...'<span style='mso-spacerun:yes'>             </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>          </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'.b a.'<span style='mso-spacerun:yes'>               </span>'.b a.'<span style='mso-spacerun:yes'>           </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>   </span><span +class=GramE>' <span class=SpellE>'</span></span><span style='mso-spacerun:yes'>          </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'a string'<span style='mso-spacerun:yes'>            </span>'a string'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>   </span><span +class=GramE>' <span class=SpellE>'</span></span><span style='mso-spacerun:yes'>          </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'a. .b'<span style='mso-spacerun:yes'>               </span>'a. .<span +class=GramE>b</span>'<span style='mso-spacerun:yes'>           </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre style='margin-left: +22.5pt'><span class=comment>% - show results</span></pre><pre style='margin-left: +22.5pt'><span style='mso-tab-count:2'>         </span><span class=GramE>o</span></pre><pre><i><span +style='color:gray'>o = <o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>          </span><span +class=GramE>magic</span>: 'ASORT'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>     </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE><span class=GramE>ver</span></span>: '</span></i><st1:date +Year="2005" Day="30" Month="3"><i><span style='color:gray'>30-Mar-2005</span></i></st1:date><i><span +style='color:gray'> </span></i><st1:time Minute="57" Hour="11"><i><span + style='color:gray'>11:57:07</span></i></st1:time><i><span style='color:gray'>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>          </span>time: '30-Mar-2005 11:57:17'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>       </span><span +class=GramE>runtime</span>: 0.047<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span +class=SpellE>input_class</span>: 'cell'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span +class=SpellE>input_msize</span>: [29 1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span +class=SpellE>input_bytes</span>: 2038<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span +class=SpellE>strng_class</span>: 'char'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span +class=SpellE>strng_msize</span>: [29 8]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span +class=SpellE>strng_bytes</span>: 464<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>           </span><span +class=SpellE><span class=GramE>anr</span></span>: {16x1 cell}<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>     </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE><span class=GramE>snr</span></span>: {7x1 cell}<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>     </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE><span class=GramE>str</span></span>: {6x1 cell}<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>             </span><span +class=GramE>c</span>: [29x12 char]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>             </span><span +class=GramE>t</span>: [29x12 logical]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>             </span><span +class=GramE>n</span>: [16x12 char]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>           </span><span +class=GramE>d</span>: [16x1 double]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre style='margin-left: +22.5pt'><span style='mso-tab-count:2'>         </span><span class=SpellE>o.anr</span></pre><pre><span +class=SpellE><span class=GramE><i><span style='color:gray'>ans</span></i></span></span><i><span +style='color:gray'> = <o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>   </span>'-<span +class=SpellE><span class=GramE>inf</span></span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'<span +class=GramE>x-3.2e4y</span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'<span +class=GramE>f-1.4</span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'-.1'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'+ <span +class=GramE>.1d-2</span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'.1'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f.1'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f -+1.4'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f.2'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f.3'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f.10'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'f.11'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span>'+<span +class=SpellE>inf</span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span><span class=GramE>' -</span><span +class=SpellE>nan</span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>  </span>'+ <span +class=SpellE><span class=GramE>nan</span></span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'<span +class=SpellE><span class=GramE>nan</span></span>'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre style='margin-left: +22.5pt'><span class=comment>% - run <b style='mso-bidi-font-weight:normal'>ASORT</b> with <b +style='mso-bidi-font-weight:normal'>no-space</b>/<b style='mso-bidi-font-weight: +normal'>template</b> options</span></pre><pre style='margin-left:22.5pt'><span +class=comment>%<span style='mso-spacerun:yes'>  </span><span class=GramE>NOTE</span> the impact of -w/-t order!</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span>s<span +class=GramE>={</span><span class=string>'ff - 1'</span>,<span class=string>'ff + 1'</span>,<span +class=string>'- 12'</span>};</pre><pre><i><span style='color:gray'><o:p> </o:p></span></i></pre><pre +style='margin-left:22.5pt'><span class=comment>%<span style='mso-spacerun:yes'>  </span>RAW</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span>o=<span +class=SpellE>asort</span>(s,<span class=string>'-v'</span>);</pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'INPUT'<span style='mso-spacerun:yes'>    </span>'ASCII SORT'<span style='mso-spacerun:yes'>   </span>'NUM SORT'<span style='mso-spacerun:yes'>            </span>'NUM READ'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'<span +class=GramE>ff</span> - 1'<span style='mso-spacerun:yes'>   </span>'- 12'<span style='mso-spacerun:yes'>         </span>'--- NUMERICAL'<span style='mso-spacerun:yes'>       </span>'--- NUMBERS'<span style='mso-spacerun:yes'>     </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'<span +class=GramE>ff</span> + 1'<span style='mso-spacerun:yes'>   </span>'ff + 1'<span style='mso-spacerun:yes'>       </span>'ff + 1'<span style='mso-spacerun:yes'>              </span>[<span style='mso-spacerun:yes'>               </span>1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'- 12'<span style='mso-spacerun:yes'>     </span>'ff - 1'<span style='mso-spacerun:yes'>       </span>'ff - 1'<span style='mso-spacerun:yes'>              </span>[<span style='mso-spacerun:yes'>               </span>1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>        </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span>- 12'<span style='mso-spacerun:yes'>                </span>[<span style='mso-spacerun:yes'>              </span>12]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>        </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>   </span><span style='mso-spacerun:yes'>   </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE>'</span>--- ASCII NUMBERS'<span style='mso-spacerun:yes'>   </span>'--- ASCII NUMBERS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>        </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span>--- ASCII STRINGS'<span style='mso-spacerun:yes'>   </span>'--- ASCII STRINGS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre style='margin-left: +22.5pt'><span class=comment>%<span style='mso-spacerun:yes'>  </span><span +class=GramE>remove</span> <span class=SpellE><b style='mso-bidi-font-weight: +normal'>SPACE</b>s</span></span></pre><pre style='margin-left:22.5pt'><span +style='mso-tab-count:2'>         </span>o=<span class=SpellE>asort</span>(s,<span +class=string>'-v'</span>,<span class=string>'-w'</span>);</pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'INPUT'<span style='mso-spacerun:yes'>   </span>'ASCII SORT'<span style='mso-spacerun:yes'>   </span>'NUM SORT'<span style='mso-spacerun:yes'>            </span>'NUM READ'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'ff-1' <span style='mso-spacerun:yes'>    </span>'-12'<span style='mso-spacerun:yes'>          </span>'--- NUMERICAL'<span style='mso-spacerun:yes'>       </span>'--- NUMBERS'<span style='mso-spacerun:yes'>     </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'<span +class=GramE>ff+</span>1'<span style='mso-spacerun:yes'>    </span><span +class=SpellE>'ff+1'</span><span style='mso-spacerun:yes'>         </span>'-12'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>             </span>-12]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'-12'<span style='mso-spacerun:yes'>     </span>'ff-1'<span style='mso-spacerun:yes'>   </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE>'ff-1'</span><span style='mso-spacerun:yes'>                </span>[<span style='mso-spacerun:yes'>              </span>-1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'ff+1'<span style='mso-spacerun:yes'>       </span><span style='mso-spacerun:yes'>         </span>[<span style='mso-spacerun:yes'>               </span>1]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span>--- ASCII NUMBERS'<span style='mso-spacerun:yes'>   </span>'--- ASCII NUMBERS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span>--- ASCII STRINGS'<span style='mso-spacerun:yes'>   </span>'--- ASCII STRINGS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre style='margin-left: +22.5pt'><span class=comment>%<span style='mso-spacerun:yes'>  </span><span +class=GramE>remove</span> <b style='mso-bidi-font-weight:normal'>TEMPLATE</b>(s)</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span>o=<span +class=SpellE>asort</span>(s,<span class=string>'-v'</span>,<span class=string>'-t'</span><span +class=GramE>,{</span><span class=string>'ff'</span>,<span class=string>'1'</span>});</pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'INPUT'<span style='mso-spacerun:yes'>   </span>'ASCII SORT'<span style='mso-spacerun:yes'>   </span>'NUM SORT'<span style='mso-spacerun:yes'>            </span>'NUM READ'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span><span class=GramE>' -</span> ' <span style='mso-spacerun:yes'>     </span><span +class=SpellE>'</span> + '<span style='mso-spacerun:yes'>          </span><span +class=SpellE>'</span>--- NUMERICAL'<span style='mso-spacerun:yes'>       </span>'--- NUMBERS'<span style='mso-spacerun:yes'>     </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span><span class=GramE>' +</span> ' <span style='mso-spacerun:yes'>     </span><span +class=SpellE>'</span> - '<span style='mso-spacerun:yes'>          </span><span +class=SpellE>'</span>- 2'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>               </span>2]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'- 2'<span style='mso-spacerun:yes'>     </span>'- 2'<span style='mso-spacerun:yes'>          </span>'--- ASCII NUMBERS'<span style='mso-spacerun:yes'>  </span><span style='mso-spacerun:yes'> </span>'--- ASCII NUMBERS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span>--- ASCII STRINGS'<span style='mso-spacerun:yes'>   </span>'--- ASCII STRINGS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span>' <span +class=SpellE>'</span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span> + '<span style='mso-spacerun:yes'>                 </span><span +class=SpellE>'</span> + '<span style='mso-spacerun:yes'>             </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>   </span>' <span +class=SpellE>'</span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span> - '<span style='mso-spacerun:yes'>                 </span><span +class=SpellE>'</span> - '<span style='mso-spacerun:yes'>             </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre style='margin-left: +22.5pt'><span class=comment>%<span style='mso-spacerun:yes'>  </span><span +class=GramE>remove</span> <b style='mso-bidi-font-weight:normal'>TEMPLATE</b>(s) than <span +class=SpellE><b style='mso-bidi-font-weight:normal'>SPACE</b>s</span></span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span>o=<span +class=SpellE>asort</span>(s,<span class=string>'-v'</span>,<span class=string>'-t'</span>,<span +class=string>'1'</span>,<span class=string>'-w'</span>);</pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'INPUT'<span style='mso-spacerun:yes'>   </span>'ASCII SORT'<span style='mso-spacerun:yes'>   </span>'NUM SORT'<span style='mso-spacerun:yes'>            </span>'NUM READ'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'ff-'<span style='mso-spacerun:yes'>     </span>'-2'<span style='mso-spacerun:yes'>           </span>'--- NUMERICAL'<span style='mso-spacerun:yes'>       </span>'--- NUMBERS'<span style='mso-spacerun:yes'>     </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'ff+' <span style='mso-spacerun:yes'>     </span><span +class=SpellE>'ff+'</span><span style='mso-spacerun:yes'>          </span>'-2'<span style='mso-spacerun:yes'>               </span><span style='mso-spacerun:yes'>   </span>[<span style='mso-spacerun:yes'>              </span>-2]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'-2'<span style='mso-spacerun:yes'>      </span>'ff-'<span style='mso-spacerun:yes'>          </span>'--- ASCII NUMBERS'<span style='mso-spacerun:yes'>   </span>'--- ASCII NUMBERS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span>--- ASCII STRINGS'<span style='mso-spacerun:yes'>   </span>'--- ASCII STRINGS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'ff+'<span style='mso-spacerun:yes'>                 </span><span +class=SpellE>'ff+'</span><span style='mso-spacerun:yes'>             </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>   </span><span style='mso-spacerun:yes'>    </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'ff-'<span style='mso-spacerun:yes'>                 </span><span +class=SpellE>'ff-'</span><span style='mso-spacerun:yes'>             </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre style='margin-left: +22.5pt'><span class=comment>%<span style='mso-spacerun:yes'>  </span><span +class=GramE>remove</span> <span class=SpellE><b style='mso-bidi-font-weight: +normal'>SPACE</b>s</span> than <b style='mso-bidi-font-weight:normal'>TEMPLATE</b>(s)</span></pre><pre +style='margin-left:22.5pt'><span style='mso-tab-count:2'>         </span>o=<span +class=SpellE>asort</span>(s,<span class=string>'-v'</span>,<span class=string>'-w'</span>,<span +class=string>'-t'</span>,<span class=string>'1'</span>);</pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'INPUT'<span style='mso-spacerun:yes'>   </span>'ASCII SORT'<span style='mso-spacerun:yes'>   </span>'NUM SORT'<span style='mso-spacerun:yes'>            </span>'NUM READ'<span style='mso-spacerun:yes'>        </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'ff- '<span style='mso-spacerun:yes'>    </span><span +class=SpellE>'</span>- 2'<span style='mso-spacerun:yes'>          </span>'--- NUMERICAL'<span style='mso-spacerun:yes'>  </span><span style='mso-spacerun:yes'>     </span>'--- NUMBERS'<span style='mso-spacerun:yes'>     </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>    </span>'ff+ '<span style='mso-spacerun:yes'>    </span>'ff+ '<span style='mso-spacerun:yes'>   </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE>'</span>- 2'<span style='mso-spacerun:yes'>                 </span>[<span style='mso-spacerun:yes'>               </span>2]<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'>   </span>'- 2'<span style='mso-spacerun:yes'>     </span>'ff- '<span style='mso-spacerun:yes'>   </span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>     </span><span +class=SpellE>'</span>--- ASCII NUMBERS'<span style='mso-spacerun:yes'>   </span>'--- ASCII NUMBERS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span><span +class=SpellE>'</span>--- ASCII STRINGS'<span style='mso-spacerun:yes'>   </span>'--- ASCII STRINGS'<o:p></o:p></span></i></pre><pre><i><span +style='color:gray'> <span style='mso-spacerun:yes'>   </span><span class=GramE>' <span +class=SpellE>'</span></span><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>      </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'ff+ '<span style='mso-spacerun:yes'>                </span>'ff+ '<span style='mso-spacerun:yes'>            </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><span style='mso-spacerun:yes'> </span><span style='mso-spacerun:yes'>   </span><span +class=GramE>' <span class=SpellE>'</span></span><span style='mso-spacerun:yes'>       </span><span +class=SpellE>'</span> <span class=SpellE>'</span><span style='mso-spacerun:yes'>            </span>'ff- '<span style='mso-spacerun:yes'>                </span>'ff- '<span style='mso-spacerun:yes'>            </span><o:p></o:p></span></i></pre><pre><i><span +style='color:gray'><o:p> </o:p></span></i></pre> + +<p class=footer style='tab-stops:45.8pt 91.6pt 137.4pt 183.2pt 229.0pt 274.8pt 320.6pt 366.4pt 412.2pt 458.0pt 503.8pt 549.6pt 595.4pt 641.2pt 687.0pt 732.8pt'><br> +Published with MATLAB® 7.0.4<o:p></o:p></p> + +</div> + +<!-- +##### SOURCE BEGIN ##### +% ASORT +% a pedestrian NUMERICAL SORTER of ALPHANUMERIC data + +% - create some data + d = { +% strings with one valid alphanumeric number +% sorted numerically + '-inf' + 'x-3.2e4y' + 'f-1.4' + '-.1' + '+ .1d-2' + '.1' + 'f.1' + 'f -+1.4' + 'f.2' + 'f.3' + 'f.10' + 'f.11' + '+inf' + ' -nan' + '+ nan' + 'nan' +% strings with many numbers or invalid/ambiguous numbers +% sorted in ascii dictionary order + ' nan nan' + '+ .1e-.2' + '-1 2' + 'Z12e12ez' + 'inf -inf' + 's.3TT.4' + 'z12e12ez' +% strings without numbers +% sorted in ascii dictionary order + ' . .. ' + '.' + '...' + '.b a.' + 'a string' + 'a. .b' + }; +% ... and scramble it... + rand('seed',10); + d=d(randperm(numel(d))); + +% - run ASORT with verbose output +% and keep additional results + o=asort(d,'-v','-d'); +% - or +% p=asort(char(d)); + +% - show results + o + o.anr + +% - run ASORT with no-space/template options +% NOTE the impact of -t/-w order! + s={'ff - 1','ff + 1','- 12'}; +% RAW + o=asort(s,'-v'); +% remove SPACEs + o=asort(s,'-v','-w'); +% remove TEMPLATE(s) + o=asort(s,'-v','-t',{'ff','1'}); +% remove TEMPLATE(s) than SPACEs + o=asort(s,'-v','-t','1','-w'); +% remove SPACEs than TEMPLATE(s) + o=asort(s,'-v','-w','-t','1'); + + +##### SOURCE END ##### +--> +</body> + +</html> diff --git a/sourcecodes/bnt-master/KPMtools/asdemo.m b/sourcecodes/bnt-master/KPMtools/asdemo.m new file mode 100644 index 00000000..6de98ad9 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/asdemo.m @@ -0,0 +1,70 @@ +% ASORT +% a pedestrian NUMERICAL SORTER of ALPHANUMERIC data + +% - create some data + d = { +% strings with one valid alphanumeric number +% sorted numerically + '-inf' + 'x-3.2e4y' + 'f-1.4' + '-.1' + '+ .1d-2' + '.1' + 'f.1' + 'f -+1.4' + 'f.2' + 'f.3' + 'f.10' + 'f.11' + '+inf' + ' -nan' + '+ nan' + 'nan' +% strings with many numbers or invalid/ambiguous numbers +% sorted in ascii dictionary order + ' nan nan' + '+ .1e-.2' + '-1 2' + 'Z12e12ez' + 'inf -inf' + 's.3TT.4' + 'z12e12ez' +% strings without numbers +% sorted in ascii dictionary order + ' . .. ' + '.' + '...' + '.b a.' + 'a string' + 'a. .b' + }; +% ... and scramble it... + rand('seed',10); + d=d(randperm(numel(d))); + +% - run ASORT with +% verbose output: <-v> +% keep additional results: <-d> + o=asort(d,'-v','-d'); +% - or +% p=asort(char(d),'-v','-d'); + +% - show results + o + o.anr + +% - run ASORT with no-space/template options +% NOTE the impact of -w/-t order! + s={'ff - 1','ff + 1','- 12'}; +% RAW + o=asort(s,'-v'); +% remove SPACEs + o=asort(s,'-v','-w'); +% remove TEMPLATE(s) + o=asort(s,'-v','-t',{'ff','1'}); +% remove TEMPLATE(s) than SPACEs + o=asort(s,'-v','-t','1','-w'); +% remove SPACEs than TEMPLATE(s) + o=asort(s,'-v','-w','-t','1'); + diff --git a/sourcecodes/bnt-master/KPMtools/asort.m b/sourcecodes/bnt-master/KPMtools/asort.m new file mode 100644 index 00000000..df6be4b3 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/asort.m @@ -0,0 +1,376 @@ +%[ANR,SNR,STR] = ASORT(INP,'OPT',...); +% S = ASORT(INP,'OPT',...); +% to sort alphanumeric strings numerically if +% they contain one properly formatted number +% otherwise, ascii dictionary sorting is applied +% +% INP unsorted input: +% - a char array +% - a cell array of strings +% OPT options +% -s - sorting option +% '-s','ascend' [def] +% '-s','descend' +% -st - force output form S [def: nargout dependent] +% -t - replace matching template(s) with one space +% prior to sorting +% '-t','template' +% '-t',{'template1','template2',...} +% -w - remove space(s) prior to sorting +% +% NOTE -t/-w options are processed in the +% order that they appear in +% the command line +% +% -v - verbose output [def: quiet] +% -d - debug mode +% save additional output in S +% .c: lex parser input +% .t: lex parser table +% .n: lex parser output +% .d: numbers read from .n +% +% ANR numerically sorted alphanumeric strings [eg, 'f.-1.5e+2x.x'] +% - contain one number that can be read by +% <strread> | <sscanf> +% SNR ascii dict sorted alphanumeric strings +% http://www.mathworks.com/matlabcentral/fileexchange/loadFile.do?objectId=7212# +% +% - contain more than one number [eg, 'f.-1.5e +2.x'] +% - contain incomplete|ambiguous numbers [eg, 'f.-1.5e+2.x'] +% STR ascii dict sorted strings +% - contain no numbers [eg, 'a test'] +% +% S structure with fields +% .anr +% .srn +% .str + +% created: +% us 03-Mar-2002 +% modified: +% us 30-Mar-2005 11:57:07 / TMW R14.sp2 + +%-------------------------------------------------------------------------------- +function varargout=asort(inp,varargin) + +varargout(1:nargout)={[]}; +if ~nargin + help(mfilename); + return; +end + +% - common parameters/options +n=[]; +ds=[]; +anr={}; +snr={}; +str={}; +smod='ascend'; % sorting option +tmpl={}; % template(s) +sflg=false; % output mode: structure +tflg=false; % remove template(s) +dflg=false; % debug mode +vflg=false; % verbose output +wflg=false; % remove spaces + +if nargin > 1 + ix=find(strcmp('-s',varargin)); + if ~isempty(ix) && nargin > ix(end)+1 + smod=varargin{ix(end)+1}; + end + ix=find(strcmp('-t',varargin)); + if ~isempty(ix) && nargin > ix(end)+1 + tflg=ix(end); + tmpl=varargin{ix(end)+1}; + end + if find(strcmp('-d',varargin)); + dflg=true; + end + if find(strcmp('-st',varargin)); + sflg=true; + end + if find(strcmp('-v',varargin)); + vflg=true; + end + ix=find(strcmp('-w',varargin)); + if ~isempty(ix) + wflg=ix(end); + end +end +% spec numbers +ntmpl={ + ' inf ' + '+inf ' + '-inf ' + ' nan ' + '+nan ' + '-nan ' + }; +% spec chars +ctmpl={ + '.' % decimal point + 'd' % exponent + 'e' % exponent + }; + +if nargout <= 3 + varargout{1}=inp; +else + disp(sprintf('ASORT> too many output args [%-1d/%-1d]\n',nargout,3)); + help(mfilename); + return; +end +if isempty(inp) + disp(sprintf('ASORT> input is empty')); + return; +end + +ti=clock; +winp=whos('inp'); +switch winp.class + case 'cell' + if ~iscellstr(inp) + disp(sprintf('ASORT> cell is not an array of strings')); + return; + end + inp=inp(:); + [ins,inx]=sort(inp); + case 'char' + % [ins,inx]=sortrows(inp); + inp=cstr(inp); + otherwise + disp(sprintf('ASORT> does not sort input of class <%s>',winp.class)); + return; +end + +inp=inp(:); +inp=setinp(inp,tmpl,[tflg wflg]); +[ins,inx]=sort(inp); +if strcmp(smod,'descend') + ins=ins(end:-1:1,:); + inx=inx(end:-1:1); +end +ins=inp(inx); +c=lower(char(ins)); +wins=whos('c'); +[cr,cc]=size(c); + +% - LEXICAL PARSER +%-------------------------------------------------------------------------------- +% - extend input on either side for search +c=[' '*ones(cr,2) c ' '*ones(cr,2)]; + +% - search for valid alphanumeric items in strings +% numbers/signs +t=(c>='0'&c<='9'); +t=t|c=='-'; +t=t|c=='+'; +[tr,tc]=size(t); +% decimal points +% note: valid numbers with dec points must follow these templates +% nr.nr +% sign.nr +% nr.<SPACE> +% <SPACE>.nr +ix1= t(:,1:end-2) & ... + ~isletter(c(:,1:end-2)) & ... + c(:,2:end-1)=='.'; +t(:,2:end-1)=t(:,2:end-1)|ix1; +ix1= (t(:,3:end) & ... + (~isletter(c(:,3:end)) & ... + ~isletter(c(:,1:end-2))) | ... + (c(:,3:end)=='e' | ... + c(:,3:end)=='d')) & ... + c(:,2:end-1)=='.'; +t(:,2:end-1)=t(:,2:end-1)|ix1; +% t(:,3:end)=t(:,3:end)|ix1; +% signs +t(c=='-')=false; +t(c=='+')=false; +ix1= t(:,3:end) & ... + (c(:,2:end-1)=='-' | ... + c(:,2:end-1)=='+'); +t(:,2:end-1)=t(:,2:end-1)|ix1; +% exponents +ix1= t(:,1:end-2) & ... + (c(:,2:end-1)=='e' | ... + c(:,2:end-1)=='d'); +t(:,2:end-1)=t(:,2:end-1)|ix1; +% spec numbers +c=reshape(c.',1,[]); +t=t'; +ic=[]; +for j=1:numel(ntmpl) + ic=[ic,strfind(c,ntmpl{j})]; +end +ic=sort(ic); +for i=1:numel(ic) + ix=ic(i)+0:ic(i)+4; + t(ix)=true; +end +t=t'; +c=reshape(c.',[tc,tr]).'; +t(c==' ')=false; +%-------------------------------------------------------------------------------- + +% - only allow one number per string +il=~any(t,2); +ib=strfind(reshape(t.',1,[]),[0 1]); +if ~isempty(ib) + ixe=cell(3,1); + n=reshape(char(t.*c).',1,[]); + for i=1:numel(ctmpl) + id=strfind(n,ctmpl{i}); + if ~isempty(id) + [dum,dum,ixu{i},ixe{i}]=dupinx(id,tc); + end + end + in=false(tr,1); + im=in; + % must check for anomalous cases like <'.d'> + id=sort(... + [find(n>='0' & n<='9'),... + strfind(n,'inf'),... + strfind(n,'nan')]); + % [ibu,ibd,ixbu,ixe{i+1}]=dupinx(id,tc); + [ibu,ibd,ixbu,ixbd]=dupinx(id,tc); + in(ixbu)=true; + in(ixbd)=true; + [ibu,ibd,ixbu,ixbd]=dupinx(ib,tc); + im(ixbu)=true; + in=in&im; + in([ixe{:}])=false; + il=~any(t,2); + ia=~(in|il); + + % - read valid strings + n=t(in,:).*c(in,:); + n(n==0)=' '; + n=char(n); + dn=strread(n.','%n'); + if numel(dn) ~= numel(find(in)) + %disp(sprintf('ASORT> unexpected fatal error reading input!')); + if nargout + s.c=c; + s.t=t; + s.n=n; + s.d=dn; + varargout{1}=s; + end + return; + end + + % - sort numbers + [ds,dx]=sort(dn,1,smod); + in=find(in); + anr=ins(in(dx)); + snr=ins(ia); +end +str=ins(il); +to=clock; + +% - prepare output +if nargout < 3 || sflg + s.magic='ASORT'; + s.ver='30-Mar-2005 11:57:07'; + s.time=datestr(clock); + s.runtime=etime(to,ti); + s.input_class=winp.class; + s.input_msize=winp.size; + s.input_bytes=winp.bytes; + s.strng_class=wins.class; + s.strng_msize=wins.size; + s.strng_bytes=wins.bytes; + s.anr=anr; + s.snr=snr; + s.str=str; + if dflg + s.c=c; + s.t=t; + s.n=n; + s.d=ds; + end + varargout{1}=s; +else + s={anr,snr,str}; + for i=1:nargout + varargout{i}=s{i}; + end +end + +if vflg + inp=cstr(inp); + an=[{'--- NUMERICAL'}; anr]; + as=[{'--- ASCII NUMBERS'}; snr]; + at=[{'--- ASCII STRINGS'}; str]; + nn=[{'--- NUMBERS'}; num2cell(ds)]; + ag={' ';' ';' '}; + u=[{'INPUT'}; inp;ag]; + v=[{'ASCII SORT'}; ins;ag]; + w=[{'NUM SORT'}; an;as;at]; + x=[{'NUM READ'}; nn;as;at]; + w=[u,v,w,x]; + disp(w); +end + +return; +%-------------------------------------------------------------------------------- +function c=cstr(s) +% - bottleneck waiting for a good <cellstr> replacement +% it consumes ~75% of <asort>'s processing time! + +c=s; +if ischar(s) + sr=size(s,1); + c=cell(sr,1); + for i=1:sr + c{i}=s(i,:); % no deblanking! + end +end +return; +%-------------------------------------------------------------------------------- +function [idu,idd,ixu,ixd]=dupinx(ix,nc) +% - check for more than one entry/row in a matrix of column size <nc> +% unique indices: idu / ixu +% duplicate indices: idd / ixd + +if isempty(ix) + idu=[]; + idd=[]; + ixu=[]; + ixd=[]; + return; +end +id=fix(ix/nc)+1; +idi=diff(id)~=0; +ide=[true idi]; +idb=[idi true]; +idu=idb & ide; +idd=idb==1 & ide==0; +ixu=id(idu); +ixd=id(idd); +return; +%-------------------------------------------------------------------------------- +function inp=setinp(inp,tmpl,flg) +% - remove space(s) and/or templates + +if isempty(inp) || ~any(flg) + return; +end + +for i=sort(flg) + switch i + case flg(1) + if ischar(tmpl) + tmpl={tmpl}; + end + for i=1:numel(tmpl) + inp=strrep(inp,tmpl{i},' '); + end + case flg(2) + inp=strrep(inp,' ',''); + end +end +return; +%-------------------------------------------------------------------------------- diff --git a/sourcecodes/bnt-master/KPMtools/assertBNT.m b/sourcecodes/bnt-master/KPMtools/assertBNT.m new file mode 100644 index 00000000..2d0cf960 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/assertBNT.m @@ -0,0 +1,10 @@ +function assertBNT(pred, str) +% ASSERT Raise an error if the predicate is not true. +% assert(pred, string) + +if nargin<2, str = ''; end + +if ~pred + s = sprintf('assertion violated: %s', str); + error(s); +end diff --git a/sourcecodes/bnt-master/KPMtools/assignEdgeNums.m b/sourcecodes/bnt-master/KPMtools/assignEdgeNums.m new file mode 100644 index 00000000..5d9a2a0d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/assignEdgeNums.m @@ -0,0 +1,32 @@ +function [edge_id, nedges] = assignEdgeNums(adj_mat) +% give each edge a unique number +% we number (i,j) for j>i first, in row, column order. +% Then we number the reverse links + +nnodes = length(adj_mat); +edge_id = zeros(nnodes); +e = 1; +for i=1:nnodes + for j=i+1:nnodes + if adj_mat(i,j) + edge_id(i,j) = e; + e = e+1; + end + end +end + +nedges = e-1; +tmp = edge_id; +ndx = find(tmp); +tmp(ndx) = tmp(ndx)+nedges; +edge_id = edge_id + triu(tmp)'; + + +if 0 +ndx = find(adj_mat); +nedges = length(ndx); +nnodes = length(adj_mat); +edge_id = zeros(1, nnodes*nnodes); +edge_id(ndx) = 1:nedges; +edge_id = reshape(edge_id, nnodes, nnodes); +end diff --git a/sourcecodes/bnt-master/KPMtools/assign_cols.m b/sourcecodes/bnt-master/KPMtools/assign_cols.m new file mode 100644 index 00000000..84cc9199 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/assign_cols.m @@ -0,0 +1,36 @@ +function M = assign_cols(cols, vals, M) +% ASSIGN_COLS Assign values to columns of a matrix +% function M = assign_cols(M, cols, vals, M) +% +% Example: +% M = assign_cols(data, ones(1,N)) +% will construct a 1-of-K encoding of the data, where K=ncols=max(data) and N=nrows=length(data) +% +% Example: +% M = zeros(3,2); +% M = assign_cols([1 2 1], [10 20 30], M) +% is equivalent to +% M(1, 1) = 10 +% M(2, 2) = 20 +% M(3, 1) = 30 +% + +if nargin < 3 + nr = length(cols); + nc = max(cols); + M = zeros(nr, nc); +else + [nr nc] = size(M); +end + +if 0 +for r=1:nr + M(r, cols(r)) = vals(r); +end +end + +if 1 +rows = 1:nr; +ndx = subv2ind([nr nc], [rows(:) cols(:)]); +M(ndx) = vals; +end diff --git a/sourcecodes/bnt-master/KPMtools/axis_pct.m b/sourcecodes/bnt-master/KPMtools/axis_pct.m new file mode 100644 index 00000000..208481eb --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/axis_pct.m @@ -0,0 +1,70 @@ +function ax = axis_pct(pct) +% AXIS_PCT Set reasonable axis limits. +% AXIS_PCT(pct) sets axis limits to extend pct% beyond limits of plotted +% objects. Default is 5%. +% Works for linear or log scale. +% Unfortunately, the axes won't change when new points are plotted. + +if nargin < 1 + pct = 0.05; +end +ax = [Inf -Inf Inf -Inf Inf -Inf]; + +% find bounding box of plotted objects +children = get(gca,'children'); +for child = children' + if strcmp(get(child,'type'),'text') + xyz = get(child,'position'); + % need to determine bounding box of the text + c([1 2]) = xyz(1); + c([3 4]) = xyz(2); + c([5 6]) = xyz(3); + else + x = get(child,'xdata'); + c(1) = min(x); + c(2) = max(x); + y = get(child,'ydata'); + c(3) = min(y); + c(4) = max(y); + z = get(child,'zdata'); + if isempty(z) + c([5 6]) = 0; + else + c(5) = min(z); + c(6) = max(z); + end + end + ax([1 3 5]) = min(ax([1 3 5]), c([1 3 5])); + ax([2 4 6]) = max(ax([2 4 6]), c([2 4 6])); +end +if strcmp(get(gca,'xscale'), 'log') + ax([1 2]) = log(ax([1 2])); +end +if strcmp(get(gca,'yscale'), 'log') + ax([3 4]) = log(ax([3 4])); +end +dx = ax(2)-ax(1); +if dx == 0 + dx = 1; +end +dy = ax(4)-ax(3); +if dy == 0 + dy = 1; +end +dz = ax(6)-ax(5); +if dz == 0 + dz = 1; +end +ax = ax + [-dx dx -dy dy -dz dz]*pct; +if strcmp(get(gca,'xscale'), 'log') + ax([1 2]) = exp(ax([1 2])); +end +if strcmp(get(gca,'yscale'), 'log') + ax([3 4]) = exp(ax([3 4])); +end +% clip for 2D +ax = ax(1:length(axis)); +axis(ax); +if nargout < 1 + clear ax +end diff --git a/sourcecodes/bnt-master/KPMtools/bipartiteMatchingDemo.m b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingDemo.m new file mode 100644 index 00000000..112547be --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingDemo.m @@ -0,0 +1,112 @@ +% Consider matching sources to detections + +% s1 d2 +% s2 d3 +% d1 + +%a = bipartiteMatchingHungarian([52;0.01]) + +% sources(:,i) = [x y] coords +sources = [0.1 0.7; 0.6 0.4]'; +detections = [0.2 0.2; 0.2 0.8; 0.7 0.1]'; +dst = sqdist(sources, detections); + +% a = [2 3] which means s1-d2, s2-d3 +a = bipartiteMatchingHungarian(dst); +a2 = bipartiteMatchingIntProg(dst); +assert(isequal(a(:),a2(:))) + + +figure(1); clf +bipartiteMatchingDemoPlot(sources, detections, a) + + + + +%%%% Flip roles of sources and detections + +%dst = dst'; +dst = sqdist(detections, sources); +% a = [0 1 2] which means d1-0, d2-s1, d3-s2 +a = bipartiteMatchingHungarian(dst); + +a2 = bipartiteMatchingIntProg(dst); +assert(isequal(a(:),a2(:))) + +figure(2); clf +bipartiteMatchingDemoPlot(detections, sources, a) % swapped args + + + + +%%%%%%%%%% Move s1 nearer to d1 +% d2 +% s2 d3 +% s1 d1 + +sources = [0.1 0.3; 0.6 0.4]'; +detections = [0.2 0.2; 0.2 0.8; 0.7 0.1]'; +dst = sqdist(sources, detections); + +% a = [2 3] which means s1-d2, s2-d3 +a = bipartiteMatchingHungarian(dst); +[a2, ass] = bipartiteMatchingIntProg(dst); +assert(isequal(a(:),a2(:))) + + +figure(3); clf +bipartiteMatchingDemoPlot(sources, detections, a) + + + +%%%%%%%%%% + +% Use random points + +% Generate 2D data from a mixture of 2 Gaussians (from netlab demgmm1) +randn('state', 0); rand('state', 0); +gmix = gmm(2, 2, 'spherical'); +ndat1 = 10; ndat2 = 10; ndata = ndat1+ndat2; +%gmix.centres = [0.3 0.3; 0.7 0.7]; +%gmix.covars = [0.01 0.01]; +gmix.centres = [0.5 0.5; 0.5 0.5]; +gmix.covars = [0.1 0.01]; +[x, label] = gmmsamp(gmix, ndata); + +ndx = find(label==1); +sources = x(ndx,:)'; +ndx = find(label==2); +detections = x(ndx,:)'; +dst = sqdist(sources, detections); + +[a, ass] = bipartiteMatchingIntProg(dst); +[a2] = bipartiteMatchingHungarian(dst); +assert(isequal(a(:), a2(:))) + +figure(4); clf +bipartiteMatchingDemoPlot(sources, detections, a) + +% only match 80% of points +p1 = size(sources, 2); +p2 = size(detections, 2); +nmatch = ceil(0.8*min(p1,p2)); +a2 = bipartiteMatchingIntProg(dst, nmatch); +figure(5); clf +bipartiteMatchingDemoPlot(sources, detections, a2) + + +%%% swap roles + +ndx = find(label==2); +sources = x(ndx,:)'; +ndx = find(label==1); +detections = x(ndx,:)'; +dst = sqdist(sources, detections); + +% only match 80% of points +p1 = size(sources, 2); +p2 = size(detections, 2); +nmatch = ceil(0.8*min(p1,p2)); +a2 = bipartiteMatchingIntProg(dst, nmatch); +figure(6); clf +bipartiteMatchingDemoPlot(sources, detections, a2) diff --git a/sourcecodes/bnt-master/KPMtools/bipartiteMatchingDemoPlot.m b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingDemoPlot.m new file mode 100644 index 00000000..1c9388c1 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingDemoPlot.m @@ -0,0 +1,24 @@ +function bipartiteMatchingDemoPlot(sources, detections, a) + +hold on +p1 = size(sources,2); +p2 = size(detections,2); +for i=1:p1 + h=text(sources(1,i), sources(2,i), sprintf('s%d', i)); + set(h, 'color', 'r'); +end +for i=1:p2 + h=text(detections(1,i), detections(2,i), sprintf('d%d', i)); + set(h, 'color', 'b'); +end + +if nargin < 3, return; end + +for i=1:p1 + j = a(i); + if j==0 % i not matched to anything + continue + end + line([sources(1,i) detections(1,j)], [sources(2,i) detections(2,j)]) +end +axis_pct; diff --git a/sourcecodes/bnt-master/KPMtools/bipartiteMatchingHungarian.m b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingHungarian.m new file mode 100644 index 00000000..a794ba02 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingHungarian.m @@ -0,0 +1,90 @@ +% MATCH - Solves the weighted bipartite matching (or assignment) +% problem. +% +% Usage: a = match(C); +% +% Arguments: +% C - an m x n cost matrix; the sets are taken to be +% 1:m and 1:n; C(i, j) gives the cost of matching +% items i (of the first set) and j (of the second set) +% +% Returns: +% +% a - an m x 1 assignment vector, which gives the +% minimum cost assignment. a(i) is the index of +% the item of 1:n that was matched to item i of +% 1:m. If item i (of 1:m) was not matched to any +% item of 1:n, then a(i) is zero. + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +function [a] = optimalMatching(C) + +% Trivial cases: +[p, q] = size(C); +if (p == 0) + a = []; + return; +elseif (q == 0) + a = zeros(p, 1); + return; +end + + +if 0 +% First, reduce the problem by making easy optimal matches. If two +% elements agree that they are the best match, then match them up. +[x, a] = min(C, [], 2); +[y, b] = min(C, [], 1); +u = find(1:p ~= b(a(:))); +a(u) = 0; +v = find(1:q ~= a(b(:))'); +C = C(u, v); +if (isempty(C)) return; end +end + +% Get the (new) size of the two sets, u and v. +[m, n] = size(C); + +%mx = realmax; +mx = 2*max(C(:)); +mn = -2*min(C(:)); +% Pad the affinity matrix to be square +if (m < n) + C = [C; mx * ones(n - m, n)]; +elseif (n < m) + C = [C, mx * ones(m, m - n)]; +end + +% Run the Hungarian method. First replace infinite values by the +% largest (or smallest) finite values. +C(find(isinf(C) & (C > 0))) = mx; +C(find(isinf(C) & (C < 0))) = mn; +%fprintf('running hungarian\n'); +[b, cost] = hungarian(C'); + +% Extract only the real assignments +ap = b(1:m)'; +ap(find(ap > n)) = 0; + +a = ap; +%% Incorporate this sub-assignment into the complete assignment +% k = find(ap); +% a(u(k)) = v(ap(k)); + diff --git a/sourcecodes/bnt-master/KPMtools/bipartiteMatchingIntProg.m b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingIntProg.m new file mode 100644 index 00000000..26efaba8 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/bipartiteMatchingIntProg.m @@ -0,0 +1,69 @@ +function [a,ass] = bipartiteMatchingIntProg(dst, nmatches) +% BIPARTITEMATCHINGINTPROG Use binary integer programming (linear objective) to solve for optimal linear assignment +% function a = bipartiteMatchingIntProg(dst) +% a(i) = best matching column for row i +% +% This gives the same result as bipartiteMatchingHungarian. +% +% function a = bibpartiteMatchingIntProg(dst, nmatches) +% only matches the specified number (must be <= min(size(dst))). +% This can be used to allow outliers in both source and target. +% +% For details, see Marciel & Costeira, "A global solution to sparse correspondence +% problems", PAMI 25(2), 2003 + +if nargin < 2, nmatches = []; end + +[p1 p2] = size(dst); +p1orig = p1; p2orig = p2; +dstorig = dst; + +if isempty(nmatches) % no outliers allowed (modulo size difference) + % ensure matrix is square + m = max(dst(:)); + if p1<p2 + dst = [dst; m*ones(p2-p1, p2)]; + elseif p1>p2 + dst = [dst m*ones(p1, p1-p2)]; + end +end +[p1 p2] = size(dst); + + +c = dst(:); % vectorize cost matrix + +% row-sum: ensure each column sums to 1 +A2 = kron(eye(p2), ones(1,p1)); +b2 = ones(p2,1); + +% col-sum: ensure each row sums to 1 +A3 = kron(ones(1,p2), eye(p1)); +b3 = ones(p1,1); + +if isempty(nmatches) + % enforce doubly stochastic + A = [A2; A3]; + b = [b2; b3]; + Aineq = zeros(1, p1*p2); + bineq = 0; +else + nmatches = min([nmatches, p1, p2]); + Aineq = [A2; A3]; + bineq = [b2; b3]; % row and col sums <= 1 + A = ones(1,p1*p2); + b = nmatches; % total num matches = b (otherwise get degenerate soln) +end + + +ass = bintprog(c, Aineq, bineq, A, b); +ass = reshape(ass, p1, p2); + +a = zeros(1, p1orig); +for i=1:p1orig + ndx = find(ass(i,:)==1); + if ~isempty(ndx) & (ndx <= p2orig) + a(i) = ndx; + end +end + + diff --git a/sourcecodes/bnt-master/KPMtools/block.m b/sourcecodes/bnt-master/KPMtools/block.m new file mode 100644 index 00000000..9a4728bc --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/block.m @@ -0,0 +1,15 @@ +function sub = block(blocks, block_sizes) +% BLOCK Return a vector of subscripts corresponding to the specified blocks. +% sub = block(blocks, block_sizes) +% +% e.g., block([2 5], [2 1 2 1 2]) = [3 7 8]. + +blocks = blocks(:)'; +block_sizes = block_sizes(:)'; +skip = [0 cumsum(block_sizes)]; +start = skip(blocks)+1; +fin = start + block_sizes(blocks) - 1; +sub = []; +for j=1:length(blocks) + sub = [sub start(j):fin(j)]; +end diff --git a/sourcecodes/bnt-master/KPMtools/cell2matPad.m b/sourcecodes/bnt-master/KPMtools/cell2matPad.m new file mode 100644 index 00000000..5b9e94a1 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/cell2matPad.m @@ -0,0 +1,22 @@ +function data2 = cell2matPad(data) +% data{f}(y,x,b) - each frame can have a different size (can can even be empty) +% data2(y,x,b,f) = zero padded version + +Nframes = length(data); +Nbands = -inf; +nr = -inf; nc = -inf; +for f=1:Nframes + if isempty(data{f}), continue; end + nr = max(nr, size(data{f},1)); + nc = max(nc, size(data{f},2)); + Nbands = max(Nbands, size(data{f},3)); +end +data2 = zeros(nr, nc, Nbands, Nframes); +for f=1:Nframes + if isempty(data{f}), continue; end + data2(1:size(data{f},1), 1:size(data{f},2), :, f) = data{f}; +end +if Nbands == 1 + data2 = squeeze(data2); % reshape(data2, [size(data2,1), size(data2,2), Nframes]); +end + diff --git a/sourcecodes/bnt-master/KPMtools/cell2num.m b/sourcecodes/bnt-master/KPMtools/cell2num.m new file mode 100644 index 00000000..ffd25ce9 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/cell2num.m @@ -0,0 +1,57 @@ +function N = cell2num(C) +% CELL2NUM Convert a 2D cell array to a 2D numeric array +% N = cell2num(C) +% If the cells contain column vectors, they must have the same number of rows in each row of C. +% Each column will be concatenated. +% +% Example 1: +% C = num2cell(rand(2,2)) +% [0.4565] [0.8214] +% [0.0185] [0.4447] +% N = cell2num(C) +% 0.4565 0.8214 +% 0.0185 0.4447 +% +% Example 2: +% C = cell(2, 3); +% for i=1:2 +% for j=1:3 +% C{i,j} = rand(i, 1); +% end +% end +% C = +% [ 0.8998] [ 0.8216] [ 0.6449] +% [2x1 double] [2x1 double] [2x1 double] +% C{2,1} = +% 0.8180 +% 0.6602 +% N=cell2num(C) +% 0.8998 0.8216 0.6449 +% 0.8180 0.3420 0.3412 +% 0.6602 0.2897 0.5341 + + +% error('use cell2mat in matlab 7') + + +if isempty(C) + N = []; + return; +end + +if any(cellfun('isempty', C)) %any(isemptycell(C)) + error('can''t convert cell array with empty cells to matrix') +end + +[nrows ncols] = size(C); +%N = reshape(cat(1, C{:}), [nrows ncols]); % this only works if C only contains scalars +r = 0; +for i=1:nrows + r = r + size(C{i,1}, 1); +end +c = 0; +for j=1:ncols + c = c + size(C{1,j}, 2); +end +N = reshape(cat(1, C{:}), [r c]); + diff --git a/sourcecodes/bnt-master/KPMtools/centeringMatrix.m b/sourcecodes/bnt-master/KPMtools/centeringMatrix.m new file mode 100644 index 00000000..92623a0d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/centeringMatrix.m @@ -0,0 +1,8 @@ +N = 3; +x = rand(N,2); % each row is a feature vector +m = mean(x,1); +xc = x-repmat(m, N, 1); + +C = eye(N) - (1/N)*ones(N,N); +xc2 = C*x; +assert(approxeq(xc, xc2)) diff --git a/sourcecodes/bnt-master/KPMtools/checkpsd.m b/sourcecodes/bnt-master/KPMtools/checkpsd.m new file mode 100644 index 00000000..cbd35203 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/checkpsd.m @@ -0,0 +1,15 @@ +function s = checkpsd(s) + +if (any(isnan(s) | isinf(s) | ~isreal(s))) + warning('S contains complex numbers, Inf, or NaN'); +end +% Drop any negative eigenvalues. +[V, D] = eig(full(s)); +d = real(diag(D)); +if (any(d < 0)) + warning(sprintf(['S is not positive semidefinite (min. eig. =' ... + ' %0.5g); projecting.'], min(d))); + d(find(d < 0)) = 0; + D = diag(d); + s = V * D * V'; +end diff --git a/sourcecodes/bnt-master/KPMtools/chi2inv.m b/sourcecodes/bnt-master/KPMtools/chi2inv.m new file mode 100644 index 00000000..90c60258 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/chi2inv.m @@ -0,0 +1,36 @@ +function x = chi2inv(p,v); +%CHI2INV Inverse of the chi-square cumulative distribution function (cdf). +% X = CHI2INV(P,V) returns the inverse of the chi-square cdf with V +% degrees of freedom at the values in P. The chi-square cdf with V +% degrees of freedom, is the gamma cdf with parameters V/2 and 2. +% +% The size of X is the common size of P and V. A scalar input +% functions as a constant matrix of the same size as the other input. + +% References: +% [1] M. Abramowitz and I. A. Stegun, "Handbook of Mathematical +% Functions", Government Printing Office, 1964, 26.4. +% [2] E. Kreyszig, "Introductory Mathematical Statistics", +% John Wiley, 1970, section 10.2 (page 144) + +% Copyright 1993-2002 The MathWorks, Inc. +% $Revision: 1.1.1.1 $ $Date: 2005/04/26 02:30:30 $ + +if nargin < 2, + error('Requires two input arguments.'); +end + +[errorcode p v] = distchck(2,p,v); + +if errorcode > 0 + error('Requires non-scalar arguments to match in size.'); +end + +% Call the gamma inverse function. +x = gaminv(p,v/2,2); + +% Return NaN if the degrees of freedom is not positive. +k = (v <= 0); +if any(k(:)) + x(k) = NaN; +end diff --git a/sourcecodes/bnt-master/KPMtools/choose.m b/sourcecodes/bnt-master/KPMtools/choose.m new file mode 100644 index 00000000..32540548 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/choose.m @@ -0,0 +1,5 @@ +function c = choose(n,k) +% CHOOSE The number of ways of choosing k things from n +% c = choose(n,k) + +c = factorial(n)/(factorial(k) * factorial(n-k)); diff --git a/sourcecodes/bnt-master/KPMtools/collapse_mog.m b/sourcecodes/bnt-master/KPMtools/collapse_mog.m new file mode 100644 index 00000000..2fe6436f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/collapse_mog.m @@ -0,0 +1,22 @@ +function [new_mu, new_Sigma, new_Sigma2] = collapse_mog(mu, Sigma, coefs) +% COLLAPSE_MOG Collapse a mixture of Gaussians to a single Gaussian by moment matching +% [new_mu, new_Sigma] = collapse_mog(mu, Sigma, coefs) +% +% coefs(i) - weight of i'th mixture component +% mu(:,i), Sigma(:,:,i) - params of i'th mixture component + +% S = sum_c w_c (S_c + m_c m_c' + m m' - 2 m_c m') +% = sum_c w_c (S_c + m_c m_c') + m m' - 2 (sum_c m_c) m' +% = sum_c w_c (S_c + m_c m_c') - m m' + +new_mu = sum(mu * diag(coefs), 2); % weighted sum of columns + +n = length(new_mu); +new_Sigma = zeros(n,n); +new_Sigma2 = zeros(n,n); +for j=1:length(coefs) + m = mu(:,j) - new_mu; + new_Sigma = new_Sigma + coefs(j) * (Sigma(:,:,j) + m*m'); + new_Sigma2 = new_Sigma2 + coefs(j) * (Sigma(:,:,j) + mu(:,j)*mu(:,j)'); +end +%assert(approxeq(new_Sigma, new_Sigma2 - new_mu*new_mu')) diff --git a/sourcecodes/bnt-master/KPMtools/colmult.c b/sourcecodes/bnt-master/KPMtools/colmult.c new file mode 100644 index 00000000..e9d5008c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/colmult.c @@ -0,0 +1,62 @@ +#include <stdio.h> +#include "mex.h" + +/* +out = colop(M, v) + +Apply binary operator to a vector v and to each column of M in turn +to produce a matrix the same size as M. + +This is equivalent to + +out = zeros(size(M)); +for col=1:size(M,2) + out(:,col) = op(M(:,col), v); +end + +The code needs to be modified for each different operator 'op'. +eg op = '.*' + +In vectorized form: + +out = M .* repmat(v(:), 1, size(M,2)) + +(This function was formerly called repmat_and_mult.c) + +*/ + +/* M(i,j) = M(i + nrows*j) since Matlab uses Fortran layout. */ + + +#define INMAT(i,j) M[(i)+nrows*(j)] +#define OUTMAT(i,j) out[(i)+nrows*(j)] + +void mexFunction( + int nlhs, mxArray *plhs[], + int nrhs, const mxArray *prhs[] + ) +{ + double *out, *M, *v; + int nrows, ncols, r, c; + + /* read the input args */ + M = mxGetPr(prhs[0]); + nrows = mxGetM(prhs[0]); + ncols = mxGetN(prhs[0]); + + v = mxGetPr(prhs[1]); + + plhs[0] = mxCreateDoubleMatrix(nrows, ncols, mxREAL); + out = mxGetPr(plhs[0]); + + for (c=0; c < ncols; c++) { + for (r=0; r < nrows; r++) { + OUTMAT(r,c) = INMAT(r,c) * v[r]; + /* printf("r=%d, c=%d, M=%f, v=%f\n", r, c, INMAT(r,c), v[r]); */ + } + } + +} + + + diff --git a/sourcecodes/bnt-master/KPMtools/computeROC.m b/sourcecodes/bnt-master/KPMtools/computeROC.m new file mode 100644 index 00000000..3b35332c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/computeROC.m @@ -0,0 +1,64 @@ +function [FPrate, TPrate, AUC, thresholds] = computeROC(confidence, testClass) +% function [FPrate, TPrate, AUC, thresholds] = computeROC(confidence, testClass) +% +% computeROC computes the data for an ROC curve based on a classifier's confidence output. +% It returns the false positive rate and the true positive rate along with +% the area under the ROC curve, and the list of thresholds. +% +% Inputs: +% - confidence(i) is proportional to the probability that +% testClass(i) is positive +% +% testClass = 0 => target absent +% testClass = 1 => target present +% +% Based on algorithms 2 and 4 from Tom Fawcett's paper "ROC Graphs: Notes and +% Practical Considerations for Data Mining Researchers" (2003) +% http://www.hpl.hp.com/techreports/2003/HPL-2003-4.pdf" +% +% Vlad Magdin, 21 Feb 2005 + +% break ties in scores +S = rand('state'); +rand('state',0); +confidence = confidence + rand(size(confidence))*10^(-10); +rand('state',S) +[thresholds order] = sort(confidence, 'descend'); +testClass = testClass(order); + +%%% -- calculate TP/FP rates and totals -- %%% +AUC = 0; +faCnt = 0; +tpCnt = 0; +falseAlarms = zeros(1,size(thresholds,2)); +detections = zeros(1,size(thresholds,2)); +fPrev = -inf; +faPrev = 0; +tpPrev = 0; + +P = max(size(find(testClass==1))); +N = max(size(find(testClass==0))); + +for i=1:length(thresholds) + if thresholds(i) ~= fPrev + falseAlarms(i) = faCnt; + detections(i) = tpCnt; + + AUC = AUC + polyarea([faPrev faPrev faCnt/N faCnt/N],[0 tpPrev tpCnt/P 0]); + + fPrev = thresholds(i); + faPrev = faCnt/N; + tpPrev = tpCnt/P; + end + + if testClass(i) == 1 + tpCnt = tpCnt + 1; + else + faCnt = faCnt + 1; + end +end + +AUC = AUC + polyarea([faPrev faPrev 1 1],[0 tpPrev 1 0]); + +FPrate = falseAlarms/N; +TPrate = detections/P; diff --git a/sourcecodes/bnt-master/KPMtools/compute_counts.m b/sourcecodes/bnt-master/KPMtools/compute_counts.m new file mode 100644 index 00000000..d710bfcb --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/compute_counts.m @@ -0,0 +1,17 @@ +function count = compute_counts(data, sz) +% COMPUTE_COUNTS Count the number of times each combination of discrete assignments occurs +% count = compute_counts(data, sz) +% +% data(i,t) is the value of variable i in case t +% sz(i) : values for variable i are assumed to be in [1:sz(i)] +% +% Example: to compute a transition matrix for an HMM from a sequence of labeled states: +% transmat = mk_stochastic(compute_counts([seq(1:end-1); seq(2:end)], [nstates nstates])); + +assert(length(sz) == size(data, 1)); +P = prod(sz); +indices = subv2ind(sz, data'); % each row of data' is a case +%count = histc(indices, 1:P); +count = hist(indices, 1:P); +count = myreshape(count, sz); + diff --git a/sourcecodes/bnt-master/KPMtools/conf2mahal.m b/sourcecodes/bnt-master/KPMtools/conf2mahal.m new file mode 100644 index 00000000..8e96dd18 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/conf2mahal.m @@ -0,0 +1,62 @@ +% CONF2MAHAL - Translates a confidence interval to a Mahalanobis +% distance. Consider a multivariate Gaussian +% distribution of the form +% +% p(x) = 1/sqrt((2 * pi)^d * det(C)) * exp((-1/2) * MD(x, m, inv(C))) +% +% where MD(x, m, P) is the Mahalanobis distance from x +% to m under P: +% +% MD(x, m, P) = (x - m) * P * (x - m)' +% +% A particular Mahalanobis distance k identifies an +% ellipsoid centered at the mean of the distribution. +% The confidence interval associated with this ellipsoid +% is the probability mass enclosed by it. Similarly, +% a particular confidence interval uniquely determines +% an ellipsoid with a fixed Mahalanobis distance. +% +% If X is an d dimensional Gaussian-distributed vector, +% then the Mahalanobis distance of X is distributed +% according to the Chi-squared distribution with d +% degrees of freedom. Thus, the Mahalanobis distance is +% determined by evaluating the inverse cumulative +% distribution function of the chi squared distribution +% up to the confidence value. +% +% Usage: +% +% m = conf2mahal(c, d); +% +% Inputs: +% +% c - the confidence interval +% d - the number of dimensions of the Gaussian distribution +% +% Outputs: +% +% m - the Mahalanobis radius of the ellipsoid enclosing the +% fraction c of the distribution's probability mass +% +% See also: MAHAL2CONF + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +function m = conf2mahal(c, d) + +m = chi2inv(c, d); \ No newline at end of file diff --git a/sourcecodes/bnt-master/KPMtools/cross_entropy.m b/sourcecodes/bnt-master/KPMtools/cross_entropy.m new file mode 100644 index 00000000..1a7d2003 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/cross_entropy.m @@ -0,0 +1,15 @@ +function kl = cross_entropy(p, q, symmetric) +% CROSS_ENTROPY Compute the Kullback-Leibler divergence between two discrete prob. distributions +% kl = cross_entropy(p, q, symmetric) +% +% If symmetric = 1, we compute the symmetric version. Default: symmetric = 0; + +tiny = exp(-700); +if nargin < 3, symmetric = 0; end +p = p(:); +q = q(:); +if symmetric + kl = (sum(p .* log((p+tiny)./(q+tiny))) + sum(q .* log((q+tiny)./(p+tiny))))/2; +else + kl = sum(p .* log((p+tiny)./(q+tiny))); +end diff --git a/sourcecodes/bnt-master/KPMtools/dirKPM.m b/sourcecodes/bnt-master/KPMtools/dirKPM.m new file mode 100644 index 00000000..39157137 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/dirKPM.m @@ -0,0 +1,98 @@ +function filenames = dirKPM(dirname, ext, varargin) +% dirKPM Like the built-in dir command, but returns filenames as a cell array instead of a struct +% +% filenames = dirKPM(dirname) +% returns all files, except '.' and '..' +% +% filenames = dirKPM('images', '*.jpg') +% returns files with this extension +% eg filenames{1} = 'foo.jpg' etc +% +% OPTIONAL ARGUMENTS [default in brackets] +% filenames = dirKPM('images', '', param1, val1, param2, val2, ...) +% +% 'fileType'='image' ['all'] means return files with extension .jpg, .png, .bmp +% +% 'prepend'=1 [0] means preprend folder name to filename +% eg filenames{1} = 'images/foo.jpg' +% +% 'doSort'=1 [1] means sort filenames in ascending alphanumerical order (where possible) +% +% 'doRecurse'=1 [0] recursive dir, apply the same dirKPM call on all +% subfolders (decrease MAXDEPTH option to prevent recursion from branching +% too explosively) + +if nargin < 1, dirname = '.'; end + +if nargin < 2, ext = ''; end + +[fileType, prepend, doSort, doRecurse, MAXDEPTH, DEPTH] = process_options(... + varargin, 'fileType', 'all', 'prepend', 0, 'doSort', 1, 'doRecurse', 0,... + 'MAXDEPTH', 3, 'DEPTH', 0); + +tmp = dir(fullfile(dirname, ext)); +[filenames I] = setdiff({tmp.name}, {'.', '..'}); +tmp = tmp(I); + +if doRecurse && sum([tmp.isdir])>0 && DEPTH<MAXDEPTH + for fi=1:length(tmp) + subDirFilenames = {}; + + if tmp(fi).isdir + varargin = change_option( varargin, 'prepend', false ); + varargin = change_option( varargin, 'doSort', false ); + varargin = change_option( varargin, 'DEPTH', DEPTH+1 ); + subDirFilenames = dirKPM( fullfile(dirname,tmp(fi).name), ext, varargin{:} ); + + for sdfi=1:length(subDirFilenames) + subDirFilenames{sdfi} = fullfile(tmp(fi).name, subDirFilenames{sdfi}); + end + end + + + nfilenames = length(filenames); + if length(subDirFilenames)>0 + filenames(nfilenames+1:nfilenames+length(subDirFilenames)) = subDirFilenames; + end + end +end + +nfiles = length(filenames); +if nfiles==0 return; end + +switch fileType + case 'image', + for fi=1:nfiles + good(fi) = isImage(filenames{fi}); + end + filenames = filenames(find(good)); + case 'all', + % no-op + otherwise + error(sprintf('unrecognized file type %s', fileType)); +end + +if doSort +% % sort filenames alphanumerically (if possible) +% DJE, buggy, MUST save tmp.anr/snr/str or else we potentially lose +% filenames +% tmp = asort(filenames, '-s', 'ascend'); +% if ~isempty(tmp.anr) +% filenames = tmp.anr'; +% else +% filenames = tmp.str'; +% end + % if names could not be sorted, return original order + + filenames=sort(filenames); + +end + + +if prepend + nfiles = length(filenames); + for fi=1:nfiles + filenames{fi} = fullfile(dirname, filenames{fi}); + end +end + diff --git a/sourcecodes/bnt-master/KPMtools/div.m b/sourcecodes/bnt-master/KPMtools/div.m new file mode 100644 index 00000000..a76bc503 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/div.m @@ -0,0 +1,5 @@ +function d = div(a,b) +% DIV Integer division +% d = div(a,b) + +d = floor(a / b); diff --git a/sourcecodes/bnt-master/KPMtools/draw_circle.m b/sourcecodes/bnt-master/KPMtools/draw_circle.m new file mode 100644 index 00000000..5d60077d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/draw_circle.m @@ -0,0 +1,28 @@ +function h = draw_circle(x, r, outline_color, fill_color) +% draw filled circles at centers x with radii r. +% x is a matrix of columns. r is a row vector. + +n = 40; % resolution +radians = [0:(2*pi)/(n-1):2*pi]; +unitC = [sin(radians); cos(radians)]; + +% extend r if necessary +if length(r) < cols(x) + r = [r repmat(r(length(r)), 1, cols(x)-length(r))]; +end + +h = []; +% hold is needed for fill() +held = ishold; +hold on +for i=1:cols(x) + y = unitC*r(i) + repmat(x(:, i), 1, n); + if nargin < 4 + h = [h line(y(1,:), y(2,:), 'Color', outline_color)]; + else + h = [h fill(y(1,:), y(2,:), fill_color, 'EdgeColor', outline_color)]; + end +end +if ~held + hold off +end diff --git a/sourcecodes/bnt-master/KPMtools/draw_ellipse.m b/sourcecodes/bnt-master/KPMtools/draw_ellipse.m new file mode 100644 index 00000000..4effef0f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/draw_ellipse.m @@ -0,0 +1,24 @@ +function h = draw_ellipse(x, c, outline_color, fill_color) +% DRAW_ELLIPSE(x, c, outline_color, fill_color) +% Draws ellipses at centers x with covariance matrix c. +% x is a matrix of columns. c is a positive definite matrix. +% outline_color and fill_color are optional. + +n = 40; % resolution +radians = [0:(2*pi)/(n-1):2*pi]; +unitC = [sin(radians); cos(radians)]; +r = chol(c)'; + +if nargin < 3 + outline_color = 'g'; +end + +h = []; +for i=1:cols(x) + y = r*unitC + repmat(x(:, i), 1, n); + if nargin < 4 + h = [h line(y(1,:), y(2,:), 'Color', outline_color)]; + else + h = [h fill(y(1,:), y(2,:), fill_color, 'EdgeColor', outline_color)]; + end +end diff --git a/sourcecodes/bnt-master/KPMtools/draw_ellipse_axes.m b/sourcecodes/bnt-master/KPMtools/draw_ellipse_axes.m new file mode 100644 index 00000000..f6c44504 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/draw_ellipse_axes.m @@ -0,0 +1,19 @@ +function h = draw_ellipse_axes(x, c, linespec) +% DRAW_ELLIPSE_AXES(x, c, linespec) +% Draws the major and minor axes of ellipses. +% Ellipses are centered at x with covariance matrix c. +% x is a matrix of columns. c is a positive definite matrix. +% linespec is optional. + +[v,e] = eig(c); +v = v*sqrt(e); + +h = []; +for j = 1:cols(v) + x1 = repmat(x(1,:),2,1) + repmat([-1;1]*v(1,j),1,cols(x)); + x2 = repmat(x(2,:),2,1) + repmat([-1;1]*v(2,j),1,cols(x)); + h = [h line(x1,x2)]; +end +if nargin > 2 + set_linespec(h,linespec); +end diff --git a/sourcecodes/bnt-master/KPMtools/em_converged.m b/sourcecodes/bnt-master/KPMtools/em_converged.m new file mode 100644 index 00000000..2b2919e2 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/em_converged.m @@ -0,0 +1,32 @@ +function [converged, decrease] = em_converged(loglik, previous_loglik, threshold, check_increased) +% EM_CONVERGED Has EM converged? +% [converged, decrease] = em_converged(loglik, previous_loglik, threshold) +% +% We have converged if the slope of the log-likelihood function falls below 'threshold', +% i.e., |f(t) - f(t-1)| / avg < threshold, +% where avg = (|f(t)| + |f(t-1)|)/2 and f(t) is log lik at iteration t. +% 'threshold' defaults to 1e-4. +% +% This stopping criterion is from Numerical Recipes in C p423 +% +% If we are doing MAP estimation (using priors), the likelihood can decrase, +% even though the mode of the posterior is increasing. + +if nargin < 3, threshold = 1e-4; end +if nargin < 4, check_increased = 1; end + +converged = 0; +decrease = 0; + +if check_increased + if loglik - previous_loglik < -1e-3 % allow for a little imprecision + fprintf(1, '******likelihood decreased from %6.4f to %6.4f!\n', previous_loglik, loglik); + decrease = 1; +converged = 0; +return; + end +end + +delta_loglik = abs(loglik - previous_loglik); +avg_loglik = (abs(loglik) + abs(previous_loglik) + eps)/2; +if (delta_loglik / avg_loglik) < threshold, converged = 1; end diff --git a/sourcecodes/bnt-master/KPMtools/entropy.m b/sourcecodes/bnt-master/KPMtools/entropy.m new file mode 100644 index 00000000..d879cc48 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/entropy.m @@ -0,0 +1,17 @@ +function H = entropy(v, scale) +% ENTROPY Entropy log base 2 +% H = entropy(v) +% If v is a matrix, we compute the entropy of each column +% +% % H = entropy(v,1) means we scale the result so that it lies in [0,1] + +if nargin < 2, scale = 0; end + +v = v + (v==0); +H = -1 * sum(v .* log2(v), 1); % sum the rows + +if scale + n = size(v, 1); + unif = normalise(ones(n,1)); + H = H / entropy(unif); +end diff --git a/sourcecodes/bnt-master/KPMtools/exportfig.m b/sourcecodes/bnt-master/KPMtools/exportfig.m new file mode 100644 index 00000000..069146f3 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/exportfig.m @@ -0,0 +1,991 @@ +function varargout = exportfig(varargin) +%EXPORTFIG Export a figure. +% EXPORTFIG(H, FILENAME) writes the figure H to FILENAME. H is +% a figure handle and FILENAME is a string that specifies the +% name of the output file. +% +% EXPORTFIG(H, FILENAME, OPTIONS) writes the figure H to FILENAME +% with options initially specified by the structure OPTIONS. The +% field names of OPTIONS must be legal parameters listed below +% and the field values must be legal values for the corresponding +% parameter. Default options can be set in releases prior to R12 +% by storing the OPTIONS structure in the root object's appdata +% with the command +% setappdata(0,'exportfigdefaults', OPTIONS) +% and for releases after R12 by setting the preference with the +% command +% setpref('exportfig', 'defaults', OPTIONS) +% +% EXPORTFIG(...,PARAM1,VAL1,PARAM2,VAL2,...) specifies +% parameters that control various characteristics of the output +% file. Any parameter value can be the string 'auto' which means +% the parameter uses the default factory behavior, overriding +% any other default for the parameter. +% +% Format Paramter: +% 'Format' a string +% specifies the output format. Defaults to 'eps'. For a +% list of export formats type 'help print'. +% 'Preview' one of the strings 'none', 'tiff' +% specifies a preview for EPS files. Defaults to 'none'. +% +% Size Parameters: +% 'Width' a positive scalar +% specifies the width in the figure's PaperUnits +% 'Height' a positive scalar +% specifies the height in the figure's PaperUnits +% 'Bounds' one of the strings 'tight', 'loose' +% specifies a tight or loose bounding box. Defaults to 'tight'. +% 'Reference' an axes handle or a string +% specifies that the width and height parameters +% are relative to the given axes. If a string is +% specified then it must evaluate to an axes handle. +% +% Specifying only one dimension sets the other dimension +% so that the exported aspect ratio is the same as the +% figure's or reference axes' current aspect ratio. +% If neither dimension is specified the size defaults to +% the width and height from the figure's or reference +% axes' size. Tight bounding boxes are only computed for +% 2-D views and in that case the computed bounds enclose all +% text objects. +% +% Rendering Parameters: +% 'Color' one of the strings 'bw', 'gray', 'cmyk' +% 'bw' specifies that lines and text are exported in +% black and all other objects in grayscale +% 'gray' specifies that all objects are exported in grayscale +% 'rgb' specifies that all objects are exported in color +% using the RGB color space +% 'cmyk' specifies that all objects are exported in color +% using the CMYK color space +% 'Renderer' one of 'painters', 'zbuffer', 'opengl' +% specifies the renderer to use +% 'Resolution' a positive scalar +% specifies the resolution in dots-per-inch. +% 'LockAxes' one of 0 or 1 +% specifies that all axes limits and ticks should be fixed +% while exporting. +% +% The default color setting is 'bw'. +% +% Font Parameters: +% 'FontMode' one of the strings 'scaled', 'fixed' +% 'FontSize' a positive scalar +% in 'scaled' mode multiplies with the font size of each +% text object to obtain the exported font size +% in 'fixed' mode specifies the font size of all text +% objects in points +% 'DefaultFixedFontSize' a positive scalar +% in 'fixed' mode specified the default font size in +% points +% 'FontSizeMin' a positive scalar +% specifies the minimum font size allowed after scaling +% 'FontSizeMax' a positive scalar +% specifies the maximum font size allowed after scaling +% 'FontEncoding' one of the strings 'latin1', 'adobe' +% specifies the character encoding of the font +% 'SeparateText' one of 0 or 1 +% specifies that the text objects are stored in separate +% file as EPS with the base filename having '_t' appended. +% +% If FontMode is 'scaled' but FontSize is not specified then a +% scaling factor is computed from the ratio of the size of the +% exported figure to the size of the actual figure. +% +% The default 'FontMode' setting is 'scaled'. +% +% Line Width Parameters: +% 'LineMode' one of the strings 'scaled', 'fixed' +% 'LineWidth' a positive scalar +% 'DefaultFixedLineWidth' a positive scalar +% 'LineWidthMin' a positive scalar +% specifies the minimum line width allowed after scaling +% 'LineWidthMax' a positive scalar +% specifies the maximum line width allowed after scaling +% The semantics of 'Line' parameters are exactly the +% same as the corresponding 'Font' parameters, except that +% they apply to line widths instead of font sizes. +% +% Style Map Parameter: +% 'LineStyleMap' one of [], 'bw', or a function name or handle +% specifies how to map line colors to styles. An empty +% style map means styles are not changed. The style map +% 'bw' is a built-in mapping that maps lines with the same +% color to the same style and otherwise cycles through the +% available styles. A user-specified map is a function +% that takes as input a cell array of line objects and +% outputs a cell array of line style strings. The default +% map is []. +% +% Examples: +% exportfig(gcf,'fig1.eps','height',3); +% Exports the current figure to the file named 'fig1.eps' with +% a height of 3 inches (assuming the figure's PaperUnits is +% inches) and an aspect ratio the same as the figure's aspect +% ratio on screen. +% +% opts = struct('FontMode','fixed','FontSize',10,'height',3); +% exportfig(gcf, 'fig2.eps', opts, 'height', 5); +% Exports the current figure to 'fig2.eps' with all +% text in 10 point fonts and with height 5 inches. +% +% See also PREVIEWFIG, APPLYTOFIG, RESTOREFIG, PRINT. + +% Copyright 2000 Ben Hinkle +% Email bug reports and comments to bhinkle@mathworks.com + +if (nargin < 2) + error('Too few input arguments'); +end + +% exportfig(H, filename, [options,] ...) +H = varargin{1}; +if ~LocalIsHG(H,'figure') + error('First argument must be a handle to a figure.'); +end +filename = varargin{2}; +if ~ischar(filename) + error('Second argument must be a string.'); +end +paramPairs = {varargin{3:end}}; +if nargin > 2 + if isstruct(paramPairs{1}) + pcell = LocalToCell(paramPairs{1}); + paramPairs = {pcell{:}, paramPairs{2:end}}; + end +end +verstr = version; +majorver = str2num(verstr(1)); +defaults = []; +if majorver > 5 + if ispref('exportfig','defaults') + defaults = getpref('exportfig','defaults'); + end +elseif exist('getappdata') + defaults = getappdata(0,'exportfigdefaults'); +end +if ~isempty(defaults) + dcell = LocalToCell(defaults); + paramPairs = {dcell{:}, paramPairs{:}}; +end + +% Do some validity checking on param-value pairs +if (rem(length(paramPairs),2) ~= 0) + error(['Invalid input syntax. Optional parameters and values' ... + ' must be in pairs.']); +end + +auto.format = 'eps'; +auto.preview = 'none'; +auto.width = -1; +auto.height = -1; +auto.color = 'bw'; +auto.defaultfontsize=10; +auto.fontsize = -1; +auto.fontmode='scaled'; +auto.fontmin = 8; +auto.fontmax = 60; +auto.defaultlinewidth = 1.0; +auto.linewidth = -1; +auto.linemode=[]; +auto.linemin = 0.5; +auto.linemax = 100; +auto.fontencoding = 'latin1'; +auto.renderer = []; +auto.resolution = []; +auto.stylemap = []; +auto.applystyle = 0; +auto.refobj = -1; +auto.bounds = 'tight'; +explicitbounds = 0; +auto.lockaxes = 1; +auto.separatetext = 0; +opts = auto; + +% Process param-value pairs +args = {}; +for k = 1:2:length(paramPairs) + param = lower(paramPairs{k}); + if ~ischar(param) + error('Optional parameter names must be strings'); + end + value = paramPairs{k+1}; + + switch (param) + case 'format' + opts.format = LocalCheckAuto(lower(value),auto.format); + if strcmp(opts.format,'preview') + error(['Format ''preview'' no longer supported. Use PREVIEWFIG' ... + ' instead.']); + end + case 'preview' + opts.preview = LocalCheckAuto(lower(value),auto.preview); + if ~strcmp(opts.preview,{'none','tiff'}) + error('Preview must be ''none'' or ''tiff''.'); + end + case 'width' + opts.width = LocalToNum(value, auto.width); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.width) + error('Width must be a numeric scalar > 0'); + end + end + case 'height' + opts.height = LocalToNum(value, auto.height); + if ~ischar(value) | ~strcmp(value,'auto') + if(~LocalIsPositiveScalar(opts.height)) + error('Height must be a numeric scalar > 0'); + end + end + case 'color' + opts.color = LocalCheckAuto(lower(value),auto.color); + if ~strcmp(opts.color,{'bw','gray','rgb','cmyk'}) + error('Color must be ''bw'', ''gray'',''rgb'' or ''cmyk''.'); + end + case 'fontmode' + opts.fontmode = LocalCheckAuto(lower(value),auto.fontmode); + if ~strcmp(opts.fontmode,{'scaled','fixed'}) + error('FontMode must be ''scaled'' or ''fixed''.'); + end + case 'fontsize' + opts.fontsize = LocalToNum(value,auto.fontsize); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.fontsize) + error('FontSize must be a numeric scalar > 0'); + end + end + case 'defaultfixedfontsize' + opts.defaultfontsize = LocalToNum(value,auto.defaultfontsize); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.defaultfontsize) + error('DefaultFixedFontSize must be a numeric scalar > 0'); + end + end + case 'fontsizemin' + opts.fontmin = LocalToNum(value,auto.fontmin); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.fontmin) + error('FontSizeMin must be a numeric scalar > 0'); + end + end + case 'fontsizemax' + opts.fontmax = LocalToNum(value,auto.fontmax); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.fontmax) + error('FontSizeMax must be a numeric scalar > 0'); + end + end + case 'fontencoding' + opts.fontencoding = LocalCheckAuto(lower(value),auto.fontencoding); + if ~strcmp(opts.fontencoding,{'latin1','adobe'}) + error('FontEncoding must be ''latin1'' or ''adobe''.'); + end + case 'linemode' + opts.linemode = LocalCheckAuto(lower(value),auto.linemode); + if ~strcmp(opts.linemode,{'scaled','fixed'}) + error('LineMode must be ''scaled'' or ''fixed''.'); + end + case 'linewidth' + opts.linewidth = LocalToNum(value,auto.linewidth); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.linewidth) + error('LineWidth must be a numeric scalar > 0'); + end + end + case 'defaultfixedlinewidth' + opts.defaultlinewidth = LocalToNum(value,auto.defaultlinewidth); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.defaultlinewidth) + error(['DefaultFixedLineWidth must be a numeric scalar >' ... + ' 0']); + end + end + case 'linewidthmin' + opts.linemin = LocalToNum(value,auto.linemin); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.linemin) + error('LineWidthMin must be a numeric scalar > 0'); + end + end + case 'linewidthmax' + opts.linemax = LocalToNum(value,auto.linemax); + if ~ischar(value) | ~strcmp(value,'auto') + if ~LocalIsPositiveScalar(opts.linemax) + error('LineWidthMax must be a numeric scalar > 0'); + end + end + case 'linestylemap' + opts.stylemap = LocalCheckAuto(value,auto.stylemap); + case 'renderer' + opts.renderer = LocalCheckAuto(lower(value),auto.renderer); + if ~ischar(value) | ~strcmp(value,'auto') + if ~strcmp(opts.renderer,{'painters','zbuffer','opengl'}) + error(['Renderer must be ''painters'', ''zbuffer'' or' ... + ' ''opengl''.']); + end + end + case 'resolution' + opts.resolution = LocalToNum(value,auto.resolution); + if ~ischar(value) | ~strcmp(value,'auto') + if ~(isnumeric(value) & (prod(size(value)) == 1) & (value >= 0)); + error('Resolution must be a numeric scalar >= 0'); + end + end + case 'applystyle' % means to apply the options and not export + opts.applystyle = 1; + case 'reference' + if ischar(value) + if strcmp(value,'auto') + opts.refobj = auto.refobj; + else + opts.refobj = eval(value); + end + else + opts.refobj = value; + end + if ~LocalIsHG(opts.refobj,'axes') + error('Reference object must evaluate to an axes handle.'); + end + case 'bounds' + opts.bounds = LocalCheckAuto(lower(value),auto.bounds); + explicitbounds = 1; + if ~strcmp(opts.bounds,{'tight','loose'}) + error('Bounds must be ''tight'' or ''loose''.'); + end + case 'lockaxes' + opts.lockaxes = LocalToNum(value,auto.lockaxes); + case 'separatetext' + opts.separatetext = LocalToNum(value,auto.separatetext); + otherwise + error(['Unrecognized option ' param '.']); + end +end + +% make sure figure is up-to-date +drawnow; + +allLines = findall(H, 'type', 'line'); +allText = findall(H, 'type', 'text'); +allAxes = findall(H, 'type', 'axes'); +allImages = findall(H, 'type', 'image'); +allLights = findall(H, 'type', 'light'); +allPatch = findall(H, 'type', 'patch'); +allSurf = findall(H, 'type', 'surface'); +allRect = findall(H, 'type', 'rectangle'); +allFont = [allText; allAxes]; +allColor = [allLines; allText; allAxes; allLights]; +allMarker = [allLines; allPatch; allSurf]; +allEdge = [allPatch; allSurf]; +allCData = [allImages; allPatch; allSurf]; + +old.objs = {}; +old.prop = {}; +old.values = {}; + +% Process format +if strncmp(opts.format,'eps',3) & ~strcmp(opts.preview,'none') + args = {args{:}, ['-' opts.preview]}; +end + +hadError = 0; +oldwarn = warning; +try + + % lock axes limits, ticks and labels if requested + if opts.lockaxes + old = LocalManualAxesMode(old, allAxes, 'TickMode'); + old = LocalManualAxesMode(old, allAxes, 'TickLabelMode'); + old = LocalManualAxesMode(old, allAxes, 'LimMode'); + end + + % Process size parameters + figurePaperUnits = get(H, 'PaperUnits'); + oldFigureUnits = get(H, 'Units'); + oldFigPos = get(H,'Position'); + set(H, 'Units', figurePaperUnits); + figPos = get(H,'Position'); + refsize = figPos(3:4); + if opts.refobj ~= -1 + oldUnits = get(opts.refobj, 'Units'); + set(opts.refobj, 'Units', figurePaperUnits); + r = get(opts.refobj, 'Position'); + refsize = r(3:4); + set(opts.refobj, 'Units', oldUnits); + end + aspectRatio = refsize(1)/refsize(2); + if (opts.width == -1) & (opts.height == -1) + opts.width = refsize(1); + opts.height = refsize(2); + elseif (opts.width == -1) + opts.width = opts.height * aspectRatio; + elseif (opts.height == -1) + opts.height = opts.width / aspectRatio; + end + wscale = opts.width/refsize(1); + hscale = opts.height/refsize(2); + sizescale = min(wscale,hscale); + old = LocalPushOldData(old,H,'PaperPositionMode', ... + get(H,'PaperPositionMode')); + set(H, 'PaperPositionMode', 'auto'); + newPos = [figPos(1) figPos(2)+figPos(4)*(1-hscale) ... + wscale*figPos(3) hscale*figPos(4)]; + set(H, 'Position', newPos); + set(H, 'Units', oldFigureUnits); + + % process line-style map + if ~isempty(opts.stylemap) & ~isempty(allLines) + oldlstyle = LocalGetAsCell(allLines,'LineStyle'); + old = LocalPushOldData(old, allLines, {'LineStyle'}, ... + oldlstyle); + newlstyle = oldlstyle; + if ischar(opts.stylemap) & strcmpi(opts.stylemap,'bw') + newlstyle = LocalMapColorToStyle(allLines); + else + try + newlstyle = feval(opts.stylemap,allLines); + catch + warning(['Skipping stylemap. ' lasterr]); + end + end + set(allLines,{'LineStyle'},newlstyle); + end + + % Process rendering parameters + switch (opts.color) + case {'bw', 'gray'} + if ~strcmp(opts.color,'bw') & strncmp(opts.format,'eps',3) + opts.format = [opts.format 'c']; + end + args = {args{:}, ['-d' opts.format]}; + + %compute and set gray colormap + oldcmap = get(H,'Colormap'); + newgrays = 0.30*oldcmap(:,1) + 0.59*oldcmap(:,2) + 0.11*oldcmap(:,3); + newcmap = [newgrays newgrays newgrays]; + old = LocalPushOldData(old, H, 'Colormap', oldcmap); + set(H, 'Colormap', newcmap); + + %compute and set ColorSpec and CData properties + old = LocalUpdateColors(allColor, 'color', old); + old = LocalUpdateColors(allAxes, 'xcolor', old); + old = LocalUpdateColors(allAxes, 'ycolor', old); + old = LocalUpdateColors(allAxes, 'zcolor', old); + old = LocalUpdateColors(allMarker, 'MarkerEdgeColor', old); + old = LocalUpdateColors(allMarker, 'MarkerFaceColor', old); + old = LocalUpdateColors(allEdge, 'EdgeColor', old); + old = LocalUpdateColors(allEdge, 'FaceColor', old); + old = LocalUpdateColors(allCData, 'CData', old); + + case {'rgb','cmyk'} + if strncmp(opts.format,'eps',3) + opts.format = [opts.format 'c']; + args = {args{:}, ['-d' opts.format]}; + if strcmp(opts.color,'cmyk') + args = {args{:}, '-cmyk'}; + end + else + args = {args{:}, ['-d' opts.format]}; + end + otherwise + error('Invalid Color parameter'); + end + if (~isempty(opts.renderer)) + args = {args{:}, ['-' opts.renderer]}; + end + if (~isempty(opts.resolution)) | ~strncmp(opts.format,'eps',3) + if isempty(opts.resolution) + opts.resolution = 0; + end + args = {args{:}, ['-r' int2str(opts.resolution)]}; + end + + % Process font parameters + if ~isempty(opts.fontmode) + oldfonts = LocalGetAsCell(allFont,'FontSize'); + oldfontunits = LocalGetAsCell(allFont,'FontUnits'); + set(allFont,'FontUnits','points'); + switch (opts.fontmode) + case 'fixed' + if (opts.fontsize == -1) + set(allFont,'FontSize',opts.defaultfontsize); + else + set(allFont,'FontSize',opts.fontsize); + end + case 'scaled' + if (opts.fontsize == -1) + scale = sizescale; + else + scale = opts.fontsize; + end + newfonts = LocalScale(oldfonts,scale,opts.fontmin,opts.fontmax); + set(allFont,{'FontSize'},newfonts); + otherwise + error('Invalid FontMode parameter'); + end + old = LocalPushOldData(old, allFont, {'FontSize'}, oldfonts); + old = LocalPushOldData(old, allFont, {'FontUnits'}, oldfontunits); + end + if strcmp(opts.fontencoding,'adobe') & strncmp(opts.format,'eps',3) + args = {args{:}, '-adobecset'}; + end + + % Process line parameters + if ~isempty(opts.linemode) + oldlines = LocalGetAsCell(allMarker,'LineWidth'); + old = LocalPushOldData(old, allMarker, {'LineWidth'}, oldlines); + switch (opts.linemode) + case 'fixed' + if (opts.linewidth == -1) + set(allMarker,'LineWidth',opts.defaultlinewidth); + else + set(allMarker,'LineWidth',opts.linewidth); + end + case 'scaled' + if (opts.linewidth == -1) + scale = sizescale; + else + scale = opts.linewidth; + end + newlines = LocalScale(oldlines, scale, opts.linemin, opts.linemax); + set(allMarker,{'LineWidth'},newlines); + end + end + + % adjust figure bounds to surround axes + if strcmp(opts.bounds,'tight') + if (~strncmp(opts.format,'eps',3) & LocalHas3DPlot(allAxes)) | ... + (strncmp(opts.format,'eps',3) & opts.separatetext) + if (explicitbounds == 1) + warning(['Cannot compute ''tight'' bounds. Using ''loose''' ... + ' bounds.']); + end + opts.bounds = 'loose'; + end + end + warning('off'); + if ~isempty(allAxes) + if strncmp(opts.format,'eps',3) + if strcmp(opts.bounds,'loose') + args = {args{:}, '-loose'}; + end + old = LocalPushOldData(old,H,'Position', oldFigPos); + elseif strcmp(opts.bounds,'tight') + oldaunits = LocalGetAsCell(allAxes,'Units'); + oldapos = LocalGetAsCell(allAxes,'Position'); + oldtunits = LocalGetAsCell(allText,'units'); + oldtpos = LocalGetAsCell(allText,'Position'); + set(allAxes,'units','points'); + apos = LocalGetAsCell(allAxes,'Position'); + oldunits = get(H,'Units'); + set(H,'units','points'); + origfr = get(H,'position'); + fr = []; + for k=1:length(allAxes) + if ~strcmpi(get(allAxes(k),'Tag'),'legend') + axesR = apos{k}; + r = LocalAxesTightBoundingBox(axesR, allAxes(k)); + r(1:2) = r(1:2) + axesR(1:2); + fr = LocalUnionRect(fr,r); + end + end + if isempty(fr) + fr = [0 0 origfr(3:4)]; + end + for k=1:length(allAxes) + ax = allAxes(k); + r = apos{k}; + r(1:2) = r(1:2) - fr(1:2); + set(ax,'Position',r); + end + old = LocalPushOldData(old, allAxes, {'Position'}, oldapos); + old = LocalPushOldData(old, allText, {'Position'}, oldtpos); + old = LocalPushOldData(old, allText, {'Units'}, oldtunits); + old = LocalPushOldData(old, allAxes, {'Units'}, oldaunits); + old = LocalPushOldData(old, H, 'Position', oldFigPos); + old = LocalPushOldData(old, H, 'Units', oldFigureUnits); + r = [origfr(1) origfr(2)+origfr(4)-fr(4) fr(3:4)]; + set(H,'Position',r); + else + args = {args{:}, '-loose'}; + old = LocalPushOldData(old,H,'Position', oldFigPos); + end + end + + % Process text in a separate file if needed + if opts.separatetext & ~opts.applystyle + % First hide all text and export + oldtvis = LocalGetAsCell(allText,'visible'); + set(allText,'visible','off'); + oldax = LocalGetAsCell(allAxes,'XTickLabel',1); + olday = LocalGetAsCell(allAxes,'YTickLabel',1); + oldaz = LocalGetAsCell(allAxes,'ZTickLabel',1); + null = cell(length(oldax),1); + [null{:}] = deal([]); + set(allAxes,{'XTickLabel'},null); + set(allAxes,{'YTickLabel'},null); + set(allAxes,{'ZTickLabel'},null); + print(H, filename, args{:}); + set(allText,{'Visible'},oldtvis); + set(allAxes,{'XTickLabel'},oldax); + set(allAxes,{'YTickLabel'},olday); + set(allAxes,{'ZTickLabel'},oldaz); + % Now hide all non-text and export as eps in painters + [path, name, ext] = fileparts(filename); + tfile = fullfile(path,[name '_t.eps']); + tfile2 = fullfile(path,[name '_t2.eps']); + foundRenderer = 0; + for k=1:length(args) + if strncmp('-d',args{k},2) + args{k} = '-deps'; + elseif strncmp('-zbuffer',args{k},8) | ... + strncmp('-opengl', args{k},6) + args{k} = '-painters'; + foundRenderer = 1; + end + end + if ~foundRenderer + args = {args{:}, '-painters'}; + end + allNonText = [allLines; allLights; allPatch; ... + allImages; allSurf; allRect]; + oldvis = LocalGetAsCell(allNonText,'visible'); + oldc = LocalGetAsCell(allAxes,'color'); + oldaxg = LocalGetAsCell(allAxes,'XGrid'); + oldayg = LocalGetAsCell(allAxes,'YGrid'); + oldazg = LocalGetAsCell(allAxes,'ZGrid'); + [null{:}] = deal('off'); + set(allAxes,{'XGrid'},null); + set(allAxes,{'YGrid'},null); + set(allAxes,{'ZGrid'},null); + set(allNonText,'Visible','off'); + set(allAxes,'Color','none'); + print(H, tfile2, args{:}); + set(allNonText,{'Visible'},oldvis); + set(allAxes,{'Color'},oldc); + set(allAxes,{'XGrid'},oldaxg); + set(allAxes,{'YGrid'},oldayg); + set(allAxes,{'ZGrid'},oldazg); + %hack up the postscript file + fid1 = fopen(tfile,'w'); + fid2 = fopen(tfile2,'r'); + line = fgetl(fid2); + while ischar(line) + if strncmp(line,'%%Title',7) + fprintf(fid1,'%s\n',['%%Title: ', tfile]); + elseif (length(line) < 3) + fprintf(fid1,'%s\n',line); + elseif ~strcmp(line(end-2:end),' PR') & ... + ~strcmp(line(end-1:end),' L') + fprintf(fid1,'%s\n',line); + end + line = fgetl(fid2); + end + fclose(fid1); + fclose(fid2); + delete(tfile2); + + elseif ~opts.applystyle + drawnow; + print(H, filename, args{:}); + end + warning(oldwarn); + +catch + warning(oldwarn); + hadError = 1; +end + +% Restore figure settings +if opts.applystyle + varargout{1} = old; +else + for n=1:length(old.objs) + if ~iscell(old.values{n}) & iscell(old.prop{n}) + old.values{n} = {old.values{n}}; + end + set(old.objs{n}, old.prop{n}, old.values{n}); + end +end + +if hadError + error(deblank(lasterr)); +end + +% +% Local Functions +% + +function outData = LocalPushOldData(inData, objs, prop, values) +outData.objs = {objs, inData.objs{:}}; +outData.prop = {prop, inData.prop{:}}; +outData.values = {values, inData.values{:}}; + +function cellArray = LocalGetAsCell(fig,prop,allowemptycell); +cellArray = get(fig,prop); +if nargin < 3 + allowemptycell = 0; +end +if ~iscell(cellArray) & (allowemptycell | ~isempty(cellArray)) + cellArray = {cellArray}; +end + +function newArray = LocalScale(inArray, scale, minv, maxv) +n = length(inArray); +newArray = cell(n,1); +for k=1:n + newArray{k} = min(maxv,max(minv,scale*inArray{k}(1))); +end + +function gray = LocalMapToGray1(color) +gray = color; +if ischar(color) + switch color(1) + case 'y' + color = [1 1 0]; + case 'm' + color = [1 0 1]; + case 'c' + color = [0 1 1]; + case 'r' + color = [1 0 0]; + case 'g' + color = [0 1 0]; + case 'b' + color = [0 0 1]; + case 'w' + color = [1 1 1]; + case 'k' + color = [0 0 0]; + end +end +if ~ischar(color) + gray = 0.30*color(1) + 0.59*color(2) + 0.11*color(3); +end + +function newArray = LocalMapToGray(inArray); +n = length(inArray); +newArray = cell(n,1); +for k=1:n + color = inArray{k}; + if ~isempty(color) + color = LocalMapToGray1(color); + end + if isempty(color) | ischar(color) + newArray{k} = color; + else + newArray{k} = [color color color]; + end +end + +function newArray = LocalMapColorToStyle(inArray); +inArray = LocalGetAsCell(inArray,'Color'); +n = length(inArray); +newArray = cell(n,1); +styles = {'-','--',':','-.'}; +uniques = []; +nstyles = length(styles); +for k=1:n + gray = LocalMapToGray1(inArray{k}); + if isempty(gray) | ischar(gray) | gray < .05 + newArray{k} = '-'; + else + if ~isempty(uniques) & any(gray == uniques) + ind = find(gray==uniques); + else + uniques = [uniques gray]; + ind = length(uniques); + end + newArray{k} = styles{mod(ind-1,nstyles)+1}; + end +end + +function newArray = LocalMapCData(inArray); +n = length(inArray); +newArray = cell(n,1); +for k=1:n + color = inArray{k}; + if (ndims(color) == 3) & isa(color,'double') + gray = 0.30*color(:,:,1) + 0.59*color(:,:,2) + 0.11*color(:,:,3); + color(:,:,1) = gray; + color(:,:,2) = gray; + color(:,:,3) = gray; + end + newArray{k} = color; +end + +function outData = LocalUpdateColors(inArray, prop, inData) +value = LocalGetAsCell(inArray,prop); +outData.objs = {inData.objs{:}, inArray}; +outData.prop = {inData.prop{:}, {prop}}; +outData.values = {inData.values{:}, value}; +if (~isempty(value)) + if strcmp(prop,'CData') + value = LocalMapCData(value); + else + value = LocalMapToGray(value); + end + set(inArray,{prop},value); +end + +function bool = LocalIsPositiveScalar(value) +bool = isnumeric(value) & ... + prod(size(value)) == 1 & ... + value > 0; + +function value = LocalToNum(value,auto) +if ischar(value) + if strcmp(value,'auto') + value = auto; + else + value = str2num(value); + end +end + +%convert a struct to {field1,val1,field2,val2,...} +function c = LocalToCell(s) +f = fieldnames(s); +v = struct2cell(s); +opts = cell(2,length(f)); +opts(1,:) = f; +opts(2,:) = v; +c = {opts{:}}; + +function c = LocalIsHG(obj,hgtype) +c = 0; +if (length(obj) == 1) & ishandle(obj) + c = strcmp(get(obj,'type'),hgtype); +end + +function c = LocalHas3DPlot(a) +zticks = LocalGetAsCell(a,'ZTickLabel'); +c = 0; +for k=1:length(zticks) + if ~isempty(zticks{k}) + c = 1; + return; + end +end + +function r = LocalUnionRect(r1,r2) +if isempty(r1) + r = r2; +elseif isempty(r2) + r = r1; +elseif max(r2(3:4)) > 0 + left = min(r1(1),r2(1)); + bot = min(r1(2),r2(2)); + right = max(r1(1)+r1(3),r2(1)+r2(3)); + top = max(r1(2)+r1(4),r2(2)+r2(4)); + r = [left bot right-left top-bot]; +else + r = r1; +end + +function c = LocalLabelsMatchTicks(labs,ticks) +c = 0; +try + t1 = num2str(ticks(1)); + n = length(ticks); + tend = num2str(ticks(n)); + c = strncmp(labs(1),t1,length(labs(1))) & ... + strncmp(labs(n),tend,length(labs(n))); +end + +function r = LocalAxesTightBoundingBox(axesR, a) +r = []; +atext = findall(a,'type','text','visible','on'); +if ~isempty(atext) + set(atext,'units','points'); + res=LocalGetAsCell(atext,'extent'); + for n=1:length(atext) + r = LocalUnionRect(r,res{n}); + end +end +if strcmp(get(a,'visible'),'on') + r = LocalUnionRect(r,[0 0 axesR(3:4)]); + oldunits = get(a,'fontunits'); + set(a,'fontunits','points'); + label = text(0,0,'','parent',a,... + 'units','points',... + 'fontsize',get(a,'fontsize'),... + 'fontname',get(a,'fontname'),... + 'fontweight',get(a,'fontweight'),... + 'fontangle',get(a,'fontangle'),... + 'visible','off'); + fs = get(a,'fontsize'); + + % handle y axis tick labels + ry = [0 -fs/2 0 axesR(4)+fs]; + ylabs = get(a,'yticklabels'); + yticks = get(a,'ytick'); + maxw = 0; + if ~isempty(ylabs) + for n=1:size(ylabs,1) + set(label,'string',ylabs(n,:)); + ext = get(label,'extent'); + maxw = max(maxw,ext(3)); + end + if ~LocalLabelsMatchTicks(ylabs,yticks) & ... + strcmp(get(a,'xaxislocation'),'bottom') + ry(4) = ry(4) + 1.5*ext(4); + end + if strcmp(get(a,'yaxislocation'),'left') + ry(1) = -(maxw+5); + else + ry(1) = axesR(3); + end + ry(3) = maxw+5; + r = LocalUnionRect(r,ry); + end + + % handle x axis tick labels + rx = [0 0 0 fs+5]; + xlabs = get(a,'xticklabels'); + xticks = get(a,'xtick'); + if ~isempty(xlabs) + if strcmp(get(a,'xaxislocation'),'bottom') + rx(2) = -(fs+5); + if ~LocalLabelsMatchTicks(xlabs,xticks); + rx(4) = rx(4) + 2*fs; + rx(2) = rx(2) - 2*fs; + end + else + rx(2) = axesR(4); + % exponent is still below axes + if ~LocalLabelsMatchTicks(xlabs,xticks); + rx(4) = rx(4) + axesR(4) + 2*fs; + rx(2) = -2*fs; + end + end + set(label,'string',xlabs(1,:)); + ext1 = get(label,'extent'); + rx(1) = -ext1(3)/2; + set(label,'string',xlabs(size(xlabs,1),:)); + ext2 = get(label,'extent'); + rx(3) = axesR(3) + (ext2(3) + ext1(3))/2; + r = LocalUnionRect(r,rx); + end + set(a,'fontunits',oldunits); + delete(label); +end + +function c = LocalManualAxesMode(old, allAxes, base) +xs = ['X' base]; +ys = ['Y' base]; +zs = ['Z' base]; +oldXMode = LocalGetAsCell(allAxes,xs); +oldYMode = LocalGetAsCell(allAxes,ys); +oldZMode = LocalGetAsCell(allAxes,zs); +old = LocalPushOldData(old, allAxes, {xs}, oldXMode); +old = LocalPushOldData(old, allAxes, {ys}, oldYMode); +old = LocalPushOldData(old, allAxes, {zs}, oldZMode); +set(allAxes,xs,'manual'); +set(allAxes,ys,'manual'); +set(allAxes,zs,'manual'); +c = old; + +function val = LocalCheckAuto(val, auto) +if ischar(val) & strcmp(val,'auto') + val = auto; +end diff --git a/sourcecodes/bnt-master/KPMtools/extend_domain_table.m b/sourcecodes/bnt-master/KPMtools/extend_domain_table.m new file mode 100644 index 00000000..4ed0b2cd --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/extend_domain_table.m @@ -0,0 +1,24 @@ +function B = extend_domain_table(A, smalldom, smallsz, bigdom, bigsz) +% EXTEND_DOMAIN_TABLE Expand an array so it has the desired size. +% B = extend_domain_table(A, smalldom, smallsz, bigdom, bigsz) +% +% A is the array with domain smalldom and sizes smallsz. +% bigdom is the desired domain, with sizes bigsz. +% +% Example: +% smalldom = [1 3], smallsz = [2 4], bigdom = [1 2 3 4], bigsz = [2 1 4 5], +% so B(i,j,k,l) = A(i,k) for i in 1:2, j in 1:1, k in 1:4, l in 1:5 + +if isequal(size(A), [1 1]) % a scalar + B = A; % * myones(bigsz); + return; +end + +map = find_equiv_posns(smalldom, bigdom); +sz = ones(1, length(bigdom)); +sz(map) = smallsz; +B = myreshape(A, sz); % add dimensions for the stuff not in A +sz = bigsz; +sz(map) = 1; % don't replicate along A's dimensions +B = myrepmat(B, sz(:)'); + diff --git a/sourcecodes/bnt-master/KPMtools/factorial.m b/sourcecodes/bnt-master/KPMtools/factorial.m new file mode 100644 index 00000000..7eab9a5f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/factorial.m @@ -0,0 +1,9 @@ +function x = factorial(n) +% FACTORIAL Compute n! +% x = factorial(n) + +if n == 0 + x = 1; +else + x = n*factorial(n-1); +end diff --git a/sourcecodes/bnt-master/KPMtools/filepartsLast.m b/sourcecodes/bnt-master/KPMtools/filepartsLast.m new file mode 100644 index 00000000..58c5511a --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/filepartsLast.m @@ -0,0 +1,12 @@ +function [last] = filepartsLast(fname) +% filepartsLast Return the last part of a filename (strip off directory and suffix) +% function filepartsLast(fname) +% +% Examples +% filepartsLast('C:/foo/bar') = 'bar' +% filepartsLast('C:/foo/bar.mat') = 'bar' +% filepartsLast('C:/foo/bar.mat.gz') = 'bar.mat' +% filepartsLast('bar.mat') = 'bar' + +[pathstr,name,ext,versn] = fileparts(fname); +last = name; diff --git a/sourcecodes/bnt-master/KPMtools/find_equiv_posns.m b/sourcecodes/bnt-master/KPMtools/find_equiv_posns.m new file mode 100644 index 00000000..cc2b8b1b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/find_equiv_posns.m @@ -0,0 +1,24 @@ +function p = find_equiv_posns(vsmall, vlarge) +% FIND_EQUIV_POSNS p[i] = the place where vsmall[i] occurs in vlarge. +% p = find_equiv_posns(vsmall, vlarge) +% THE VECTORS ARE ASSUMED TO BE SORTED. +% +% e.g., vsmall=[2,8], vlarge=[2,7,8,4], p=[1,3] +% +% In R/S, this function is called 'match' + +%if ~mysubset(vsmall, vlarge) +% error('small domain must occur in large domain'); +%end + +if isempty(vsmall) || isempty(vlarge) + p = []; + return; +end + +bitvec = sparse(1, max(vlarge)); +%bitvec = zeros(1, max(vlarge)); +bitvec(vsmall) = 1; +p = find(bitvec(vlarge)); + +%p = find(ismember(vlarge, vsmall)); % slower diff --git a/sourcecodes/bnt-master/KPMtools/fullfileKPM.m b/sourcecodes/bnt-master/KPMtools/fullfileKPM.m new file mode 100644 index 00000000..a3ab4432 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/fullfileKPM.m @@ -0,0 +1,6 @@ +function f = fullfileKPM(varargin) +% fullfileKPM Concatenate strings with file separator, then convert it to a/b/c +% function f = fullfileKPM(varargin) + +f = fullfile(varargin{:}); +f = strrep(f, '\', '/'); diff --git a/sourcecodes/bnt-master/KPMtools/genpathKPM.m b/sourcecodes/bnt-master/KPMtools/genpathKPM.m new file mode 100644 index 00000000..8994fc9b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/genpathKPM.m @@ -0,0 +1,45 @@ +function p = genpathKPM(d) +% genpathKPM Like built-in genpath, but omits directories whose name is 'Old', 'old' or 'CVS' +% function p = genpathKPM(d) + +if nargin==0, + p = genpath(fullfile(matlabroot,'toolbox')); + if length(p) > 1, p(end) = []; end % Remove trailing pathsep + return +end + +% initialise variables +methodsep = '@'; % qualifier for overloaded method directories +p = ''; % path to be returned + +% Generate path based on given root directory +files = dir(d); +if isempty(files) + return +end + +% Add d to the path even if it is empty. +p = [p d pathsep]; + +% set logical vector for subdirectory entries in d +isdir = logical(cat(1,files.isdir)); +% +% Recursively descend through directories which are neither +% private nor "class" directories. +% +dirs = files(isdir); % select only directory entries from the current listing + +for i=1:length(dirs) + dirname = dirs(i).name; + if ~strcmp( dirname,'.') & ... + ~strcmp( dirname,'..') & ... + ~strncmp( dirname,methodsep,1)& ... + ~strcmp( dirname,'private') & ... + ~strcmp( dirname, 'old') & ... % KPM + ~strcmp( dirname, 'Old') & ... % KPM + ~strcmp( dirname, 'CVS') % KPM + p = [p genpathKPM(fullfile(d,dirname))]; % recursive calling of this function. + end +end + +%------------------------------------------------------------------------------ diff --git a/sourcecodes/bnt-master/KPMtools/hash_add.m b/sourcecodes/bnt-master/KPMtools/hash_add.m new file mode 100644 index 00000000..f302d8f1 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/hash_add.m @@ -0,0 +1,19 @@ +function hash_add(key, val, fname) +% HASH_ADD Append key,value pair to end of hashtable stored in a file +% function hash_add(key, val, filename) +% +% See hash_lookup for an example + +if ~exist(fname, 'file') + % new hashtable + hashtable.key{1} = key; + hashtable.value{1} = val; +else + %hashtable = importdata(fname); + %hashtable = load(fname, '-mat'); + load(fname, '-mat'); + Nentries = length(hashtable.key); + hashtable.key{Nentries+1} = key; + hashtable.value{Nentries+1} = val; +end +save(fname, 'hashtable', '-mat'); diff --git a/sourcecodes/bnt-master/KPMtools/hash_del.m b/sourcecodes/bnt-master/KPMtools/hash_del.m new file mode 100644 index 00000000..c5de3daa --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/hash_del.m @@ -0,0 +1,26 @@ +function ndx = hash_del(key, fname) +% HASH_DEL Remove all entries that match key from hashtable stored in a file +% ndx = hash_del(key, fname) +% +% Returns indices of matching entries (if any) +% See hash_lookup for an example + +ndx = []; + +if ~exist(fname, 'file') + % new hashtable - no op +else + %hashtable = importdata(fname); + %hashtable = load(fname, '-mat'); + load(fname, '-mat'); + Nentries = length(hashtable.key); + for i=1:Nentries + if isequal(hashtable.key{i}, key) + ndx = [ndx i]; + end + end + hashtable.key(ndx) = []; + hashtable.value(ndx) = []; + save(fname, 'hashtable', '-mat'); +end + diff --git a/sourcecodes/bnt-master/KPMtools/hash_lookup.m b/sourcecodes/bnt-master/KPMtools/hash_lookup.m new file mode 100644 index 00000000..847c6d58 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/hash_lookup.m @@ -0,0 +1,34 @@ +function [val, found, Nentries] = hash_lookup(key, fname) +% HASH_LOOKUP Lookup a key in a hash table stored in a file using linear search +% function [val, found, Nentries] = hash_lookup(key, filename) +% +% Example: +% If htbl.mat does not exist, +% [val,found,N] = hash_lookup('foo', 'htbl') +% returns found val = [], found = 0, N = 0 +% hash_add('foo', 42, 'htbl') +% hash_add('bar', [1:10], 'htbl') +% [val,found,N] = hash_lookup('foo', 'htbl') +% now returns val = 42, found = 1, N = 2 +% +% Type 'delete htbl' to delete the file/ reset the hashtable + + +val = []; +found = 0; + +if exist(fname, 'file')==0 + % new hashtable + Nentries = 0; +else + %hashtable = importdata(fname); + load(fname); + Nentries = length(hashtable.key); + for i=1:Nentries + if isequal(hashtable.key{i}, key) + val = hashtable.value{i}; + found = 1; + break; + end + end +end diff --git a/sourcecodes/bnt-master/KPMtools/hsvKPM.m b/sourcecodes/bnt-master/KPMtools/hsvKPM.m new file mode 100644 index 00000000..29521ae5 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/hsvKPM.m @@ -0,0 +1,7 @@ +function colors = hsvKPM(N) +% hsvKPM Like built-in HSV, except it randomizes the order, so that adjacent colors are dis-similar +% function colors = hsvKPM(N) + +colors = hsv(N); +perm = randperm(N); +colors = colors(perm,:); diff --git a/sourcecodes/bnt-master/KPMtools/hungarian.m b/sourcecodes/bnt-master/KPMtools/hungarian.m new file mode 100644 index 00000000..0b493f07 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/hungarian.m @@ -0,0 +1,464 @@ +function [C,T]=hungarian(A) +%HUNGARIAN Solve the Assignment problem using the Hungarian method. +% +%[C,T]=hungarian(A) +%A - a square cost matrix. +%C - the optimal assignment. +%T - the cost of the optimal assignment. + +% Adapted from the FORTRAN IV code in Carpaneto and Toth, "Algorithm 548: +% Solution of the assignment problem [H]", ACM Transactions on +% Mathematical Software, 6(1):104-111, 1980. + +% v1.0 96-06-14. Niclas Borlin, niclas@cs.umu.se. +% Department of Computing Science, Umeå University, +% Sweden. +% All standard disclaimers apply. + +% A substantial effort was put into this code. If you use it for a +% publication or otherwise, please include an acknowledgement or at least +% notify me by email. /Niclas + +[m,n]=size(A); + +if (m~=n) + error('HUNGARIAN: Cost matrix must be square!'); +end + +% Save original cost matrix. +orig=A; + +% Reduce matrix. +A=hminired(A); + +% Do an initial assignment. +[A,C,U]=hminiass(A); + +% Repeat while we have unassigned rows. +while (U(n+1)) + % Start with no path, no unchecked zeros, and no unexplored rows. + LR=zeros(1,n); + LC=zeros(1,n); + CH=zeros(1,n); + RH=[zeros(1,n) -1]; + + % No labelled columns. + SLC=[]; + + % Start path in first unassigned row. + r=U(n+1); + % Mark row with end-of-path label. + LR(r)=-1; + % Insert row first in labelled row set. + SLR=r; + + % Repeat until we manage to find an assignable zero. + while (1) + % If there are free zeros in row r + if (A(r,n+1)~=0) + % ...get column of first free zero. + l=-A(r,n+1); + + % If there are more free zeros in row r and row r in not + % yet marked as unexplored.. + if (A(r,l)~=0 & RH(r)==0) + % Insert row r first in unexplored list. + RH(r)=RH(n+1); + RH(n+1)=r; + + % Mark in which column the next unexplored zero in this row + % is. + CH(r)=-A(r,l); + end + else + % If all rows are explored.. + if (RH(n+1)<=0) + % Reduce matrix. + [A,CH,RH]=hmreduce(A,CH,RH,LC,LR,SLC,SLR); + end + + % Re-start with first unexplored row. + r=RH(n+1); + % Get column of next free zero in row r. + l=CH(r); + % Advance "column of next free zero". + CH(r)=-A(r,l); + % If this zero is last in the list.. + if (A(r,l)==0) + % ...remove row r from unexplored list. + RH(n+1)=RH(r); + RH(r)=0; + end + end + + % While the column l is labelled, i.e. in path. + while (LC(l)~=0) + % If row r is explored.. + if (RH(r)==0) + % If all rows are explored.. + if (RH(n+1)<=0) + % Reduce cost matrix. + [A,CH,RH]=hmreduce(A,CH,RH,LC,LR,SLC,SLR); + end + + % Re-start with first unexplored row. + r=RH(n+1); + end + + % Get column of next free zero in row r. + l=CH(r); + + % Advance "column of next free zero". + CH(r)=-A(r,l); + + % If this zero is last in list.. + if(A(r,l)==0) + % ...remove row r from unexplored list. + RH(n+1)=RH(r); + RH(r)=0; + end + end + + % If the column found is unassigned.. + if (C(l)==0) + % Flip all zeros along the path in LR,LC. + [A,C,U]=hmflip(A,C,LC,LR,U,l,r); + % ...and exit to continue with next unassigned row. + break; + else + % ...else add zero to path. + + % Label column l with row r. + LC(l)=r; + + % Add l to the set of labelled columns. + SLC=[SLC l]; + + % Continue with the row assigned to column l. + r=C(l); + + % Label row r with column l. + LR(r)=l; + + % Add r to the set of labelled rows. + SLR=[SLR r]; + end + end +end + +% Calculate the total cost. +T=sum(orig(logical(sparse(C,1:size(orig,2),1)))); + + +function A=hminired(A) +%HMINIRED Initial reduction of cost matrix for the Hungarian method. +% +%B=assredin(A) +%A - the unreduced cost matris. +%B - the reduced cost matrix with linked zeros in each row. + +% v1.0 96-06-13. Niclas Borlin, niclas@cs.umu.se. + +[m,n]=size(A); + +% Subtract column-minimum values from each column. +colMin=min(A); +A=A-colMin(ones(n,1),:); + +% Subtract row-minimum values from each row. +rowMin=min(A')'; +A=A-rowMin(:,ones(1,n)); + +% Get positions of all zeros. +[i,j]=find(A==0); + +% Extend A to give room for row zero list header column. +A(1,n+1)=0; +for k=1:n + % Get all column in this row. + cols=j(k==i)'; + % Insert pointers in matrix. + A(k,[n+1 cols])=[-cols 0]; +end + + +function [A,C,U]=hminiass(A) +%HMINIASS Initial assignment of the Hungarian method. +% +%[B,C,U]=hminiass(A) +%A - the reduced cost matrix. +%B - the reduced cost matrix, with assigned zeros removed from lists. +%C - a vector. C(J)=I means row I is assigned to column J, +% i.e. there is an assigned zero in position I,J. +%U - a vector with a linked list of unassigned rows. + +% v1.0 96-06-14. Niclas Borlin, niclas@cs.umu.se. + +[n,np1]=size(A); + +% Initalize return vectors. +C=zeros(1,n); +U=zeros(1,n+1); + +% Initialize last/next zero "pointers". +LZ=zeros(1,n); +NZ=zeros(1,n); + +for i=1:n + % Set j to first unassigned zero in row i. + lj=n+1; + j=-A(i,lj); + + % Repeat until we have no more zeros (j==0) or we find a zero + % in an unassigned column (c(j)==0). + + while (C(j)~=0) + % Advance lj and j in zero list. + lj=j; + j=-A(i,lj); + + % Stop if we hit end of list. + if (j==0) + break; + end + end + + if (j~=0) + % We found a zero in an unassigned column. + + % Assign row i to column j. + C(j)=i; + + % Remove A(i,j) from unassigned zero list. + A(i,lj)=A(i,j); + + % Update next/last unassigned zero pointers. + NZ(i)=-A(i,j); + LZ(i)=lj; + + % Indicate A(i,j) is an assigned zero. + A(i,j)=0; + else + % We found no zero in an unassigned column. + + % Check all zeros in this row. + + lj=n+1; + j=-A(i,lj); + + % Check all zeros in this row for a suitable zero in another row. + while (j~=0) + % Check the in the row assigned to this column. + r=C(j); + + % Pick up last/next pointers. + lm=LZ(r); + m=NZ(r); + + % Check all unchecked zeros in free list of this row. + while (m~=0) + % Stop if we find an unassigned column. + if (C(m)==0) + break; + end + + % Advance one step in list. + lm=m; + m=-A(r,lm); + end + + if (m==0) + % We failed on row r. Continue with next zero on row i. + lj=j; + j=-A(i,lj); + else + % We found a zero in an unassigned column. + + % Replace zero at (r,m) in unassigned list with zero at (r,j) + A(r,lm)=-j; + A(r,j)=A(r,m); + + % Update last/next pointers in row r. + NZ(r)=-A(r,m); + LZ(r)=j; + + % Mark A(r,m) as an assigned zero in the matrix . . . + A(r,m)=0; + + % ...and in the assignment vector. + C(m)=r; + + % Remove A(i,j) from unassigned list. + A(i,lj)=A(i,j); + + % Update last/next pointers in row r. + NZ(i)=-A(i,j); + LZ(i)=lj; + + % Mark A(r,m) as an assigned zero in the matrix . . . + A(i,j)=0; + + % ...and in the assignment vector. + C(j)=i; + + % Stop search. + break; + end + end + end +end + +% Create vector with list of unassigned rows. + +% Mark all rows have assignment. +r=zeros(1,n); +rows=C(C~=0); +r(rows)=rows; +empty=find(r==0); + +% Create vector with linked list of unassigned rows. +U=zeros(1,n+1); +U([n+1 empty])=[empty 0]; + + +function [A,C,U]=hmflip(A,C,LC,LR,U,l,r) +%HMFLIP Flip assignment state of all zeros along a path. +% +%[A,C,U]=hmflip(A,C,LC,LR,U,l,r) +%Input: +%A - the cost matrix. +%C - the assignment vector. +%LC - the column label vector. +%LR - the row label vector. +%U - the +%r,l - position of last zero in path. +%Output: +%A - updated cost matrix. +%C - updated assignment vector. +%U - updated unassigned row list vector. + +% v1.0 96-06-14. Niclas Borlin, niclas@cs.umu.se. + +n=size(A,1); + +while (1) + % Move assignment in column l to row r. + C(l)=r; + + % Find zero to be removed from zero list.. + + % Find zero before this. + m=find(A(r,:)==-l); + + % Link past this zero. + A(r,m)=A(r,l); + + A(r,l)=0; + + % If this was the first zero of the path.. + if (LR(r)<0) + ...remove row from unassigned row list and return. + U(n+1)=U(r); + U(r)=0; + return; + else + + % Move back in this row along the path and get column of next zero. + l=LR(r); + + % Insert zero at (r,l) first in zero list. + A(r,l)=A(r,n+1); + A(r,n+1)=-l; + + % Continue back along the column to get row of next zero in path. + r=LC(l); + end +end + + +function [A,CH,RH]=hmreduce(A,CH,RH,LC,LR,SLC,SLR) +%HMREDUCE Reduce parts of cost matrix in the Hungerian method. +% +%[A,CH,RH]=hmreduce(A,CH,RH,LC,LR,SLC,SLR) +%Input: +%A - Cost matrix. +%CH - vector of column of 'next zeros' in each row. +%RH - vector with list of unexplored rows. +%LC - column labels. +%RC - row labels. +%SLC - set of column labels. +%SLR - set of row labels. +% +%Output: +%A - Reduced cost matrix. +%CH - Updated vector of 'next zeros' in each row. +%RH - Updated vector of unexplored rows. + +% v1.0 96-06-14. Niclas Borlin, niclas@cs.umu.se. + +n=size(A,1); + +% Find which rows are covered, i.e. unlabelled. +coveredRows=LR==0; + +% Find which columns are covered, i.e. labelled. +coveredCols=LC~=0; + +r=find(~coveredRows); +c=find(~coveredCols); + +% Get minimum of uncovered elements. +m=min(min(A(r,c))); + +% Subtract minimum from all uncovered elements. +A(r,c)=A(r,c)-m; + +% Check all uncovered columns.. +for j=c + % ...and uncovered rows in path order.. + for i=SLR + % If this is a (new) zero.. + if (A(i,j)==0) + % If the row is not in unexplored list.. + if (RH(i)==0) + % ...insert it first in unexplored list. + RH(i)=RH(n+1); + RH(n+1)=i; + % Mark this zero as "next free" in this row. + CH(i)=j; + end + % Find last unassigned zero on row I. + row=A(i,:); + colsInList=-row(row<0); + if (length(colsInList)==0) + % No zeros in the list. + l=n+1; + else + l=colsInList(row(colsInList)==0); + end + % Append this zero to end of list. + A(i,l)=-j; + end + end +end + +% Add minimum to all doubly covered elements. +r=find(coveredRows); +c=find(coveredCols); + +% Take care of the zeros we will remove. +[i,j]=find(A(r,c)<=0); + +i=r(i); +j=c(j); + +for k=1:length(i) + % Find zero before this in this row. + lj=find(A(i(k),:)==-j(k)); + % Link past it. + A(i(k),lj)=A(i(k),j(k)); + % Mark it as assigned. + A(i(k),j(k))=0; +end + +A(r,c)=A(r,c)+m; diff --git a/sourcecodes/bnt-master/KPMtools/image_rgb.m b/sourcecodes/bnt-master/KPMtools/image_rgb.m new file mode 100644 index 00000000..e8d65883 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/image_rgb.m @@ -0,0 +1,36 @@ +function image_rgb(M) +% Show a matrix of integers as a color image. +% This is like imagesc, except we know what the mapping is from integer to color. +% If entries of M contain integers in {1,2,3}, we map +% this to red/green/blue + +cmap = [1 0 0; % red + 0 1 0; % green + 0 0 1; % blue + 127/255 1 212/255]; % aquamarine +image(M) +set(gcf,'colormap', cmap); + +if 1 + % make dummy handles, one per object type, for the legend + str = {}; + for i=1:size(cmap,1) + dummy_handle(i) = line([0 0.1], [0 0.1]); + set(dummy_handle(i), 'color', cmap(i,:)); + set(dummy_handle(i), 'linewidth', 2); + str{i} = num2str(i); + end + legend(dummy_handle, str, -1); +end + +if 0 +[nrows ncols] = size(M); +img = zeros(nrows, ncols, 3); +for r=1:nrows + for c=1:ncols + q = M(r,c); + img(r,c,q) = 1; + end +end +image(img) +end diff --git a/sourcecodes/bnt-master/KPMtools/imresizeAspect.m b/sourcecodes/bnt-master/KPMtools/imresizeAspect.m new file mode 100644 index 00000000..a69a2de4 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/imresizeAspect.m @@ -0,0 +1,44 @@ +function img = imresizeAspect(img, maxSize) +% function img = imresizeAspect(img, maxSize) +% If image is larger than max size, reduce size, preserving aspect ratio of input. +% +% If size(input) = [y x] and maxSize = [yy xx], +% then size(output) is given by the following (where a=y/x) +% if y<yy & x<xx then [y x] +% else if a<1 then [a*xx xx] +% else [yy yy/a] + +% For why we use bilinear, +% See http://nickyguides.digital-digest.com/bilinear-vs-bicubic.htm + +if isempty(maxSize), return; end + +[y x c] = size(img); +a= y/x; +yy = maxSize(1); xx = maxSize(2); +if y <= yy & x <= xx + % no-op +else + if a < 1 + img = imresize(img, ceil([a*xx xx]), 'bilinear'); + else + img = imresize(img, ceil([yy yy/a]), 'bilinear'); + end + fprintf('resizing from %dx%d to %dx%d\n', y, x, size(img,1), size(img,2)); +end + + +%test +if 0 + maxSize = [240 320]; + %img = imread('C:\Images\Wearables\web_static_office\8.jpg'); + %img = imread('C:\Images\Wearables\web_static_office\billandkirsten.jpg'); + %img = imread('C:\Images\Wearables\web_static_street_april\p5.jpg'); + img = imread('C:\Images\Wearables\Database_static_street\art11.jpg'); + img2 = imresizeAspect(img, maxSize); + figure(1); clf; imshow(img) + figure(2); clf; imshow(img2) + fprintf('%dx%d (%5.3f) to %dx%d (%5.3f)\n', ... + size(img,1), size(img,2), size(img,1)/size(img,2), ... + size(img2,1), size(img2,2), size(img2,1)/size(img2,2)); +end diff --git a/sourcecodes/bnt-master/KPMtools/ind2subv.m b/sourcecodes/bnt-master/KPMtools/ind2subv.m new file mode 100644 index 00000000..6d9c4308 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/ind2subv.m @@ -0,0 +1,22 @@ +function sub = ind2subv(siz,index) +%IND2SUBV Subscript vector from linear index. +% IND2SUBV(SIZ,IND) returns a vector of the equivalent subscript values +% corresponding to a single index into an array of size SIZ. +% If IND is a vector, then the result is a matrix, with subscript vectors +% as rows. + +%sub = ind2subvTest(siz, index); +n = length(siz); +if n==0, sub = index; return; end % added by KPM 17 Nov 07 +cum_size = cumprod(siz(:)'); +prev_cum_size = [1 cum_size(1:end-1)]; +index = index(:) - 1; +sub = rem(repmat(index,1,n),repmat(cum_size,length(index),1)); +sub = floor(sub ./ repmat(prev_cum_size,length(index),1))+1; + +% slow way +%for dim = n:-1:1 +% sub(:,dim) = floor(index/cum_size(dim))+1; +% index = rem(index,cum_size(dim)); +%end + diff --git a/sourcecodes/bnt-master/KPMtools/ind2subvKPM.c b/sourcecodes/bnt-master/KPMtools/ind2subvKPM.c new file mode 100644 index 00000000..63a106a1 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/ind2subvKPM.c @@ -0,0 +1,176 @@ +/* C mex version of ind2subv.m in misc directory */ +/* 2 input, 1 output */ +/* siz, ndx */ +/* sub */ + +#include "mex.h" +#include <math.h> + +void rbinary(int num, int n, double *rbits){ + int i, mask; + num = num - 1; + + mask = 1 << (n-1); /* mask = 00100...0 , where the 1 is in column n (rightmost = col 1) */ + for (i = 0; i < n; i++) { + rbits[n-i-1] = ((num & mask) == 0) ? 1 : 2; + num <<= 1; + } +} + +void ind_subv(int num, const double *sizes, int n, double *rbits){ + int i; + int *cumprod; + + cumprod = malloc(n * sizeof(int)); + num = num - 1; + cumprod[0] = 1; + for (i = 0; i < n-1; i++) + cumprod[i+1] = cumprod[i] * (int)sizes[i]; + for (i = n-1; i >= 0; i--) { + rbits[i] = ((int)floor(num / cumprod[i])) + 1; + num = num % cumprod[i]; + } + free(cumprod); +} + + +void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){ + int i, j, k, nCol, nRow, nnRow, binary, count, temp, temp1, start; + double *pSize, *pNdx, *pr; + double ndx; + int *subv, *cumprod, *templai; + + pSize = mxGetPr(prhs[0]); + pNdx = mxGetPr(prhs[1]); + nCol = mxGetNumberOfElements(prhs[0]); + nnRow = mxGetNumberOfElements(prhs[1]); + + nRow = 1; + for(i=0; i<nCol; i++){ + nRow *= (int)pSize[i]; + } + + if(nCol == 0){ + plhs[0] = mxDuplicateArray(prhs[1]); + return; + } + + binary = 2; + for (i = 0; i < nCol; i++){ + if (pSize[i] > 2.0){ + binary = 0; + break; + } + else if((int)pSize[i] == 1){ + binary = 1; + } + } + + if(nnRow == 1){ + ndx = mxGetScalar(prhs[1]); + plhs[0] = mxCreateDoubleMatrix(1, nCol, mxREAL); + pr = mxGetPr(plhs[0]); + if(binary == 2)rbinary((int)ndx, nCol, pr); + else ind_subv((int)ndx, pSize, nCol, pr); + return; + } + + plhs[0] = mxCreateDoubleMatrix(nnRow, nCol, mxREAL); + pr = mxGetPr(plhs[0]); + + subv = malloc(nRow * nCol * sizeof(int)); + + if (binary == 2) { + for(j=0; j<nCol; j++){ + temp = (1 << j); + temp1 = j * nRow; + for(i=0; i<nRow; i++){ + subv[temp1 + i] = ((i & temp) == 0) ? 1 : 2; + } + } + } + else if(binary == 1){ + cumprod = (int *)malloc(nCol * sizeof(int)); + templai = (int *)malloc(nCol * sizeof(int)); + cumprod[0] = 1; + templai[0] = nRow; + for(i=1; i<nCol; i++){ + k = (int)pSize[i-1] - 1; + cumprod[i] = cumprod[i-1] << k; + templai[i] = templai[i-1] >> k; + } + for(j=0; j<nCol; j++){ + temp1 = j * nRow; + if(pSize[j] == 1.0){ + for(i=0; i<nRow; i++){ + subv[temp1 + i] = 1; + } + } + else{ + temp = 1; + count = 0; + for(i=0; i<templai[j]; i++){ + if(temp > 2) temp = 1; + for(k=0; k<cumprod[j]; k++){ + subv[temp1 + count] = temp; + count++; + } + temp++; + } + } + } + free(templai); + free(cumprod); + } + else { + cumprod = (int *)malloc(nCol * sizeof(int)); + templai = (int *)malloc(nCol * sizeof(int)); + cumprod[0] = 1; + for(i=1; i<nCol; i++){ + cumprod[i] = (int)(cumprod[i-1] * pSize[i-1]); + } + templai[0] = nRow; + for(i=1; i<nCol; i++){ + templai[i] = nRow / cumprod[i]; + } + for(j=0; j<nCol; j++){ + temp1 = j * nRow; + if(pSize[j] == 1.0){ + for(i=0; i<nRow; i++){ + subv[temp1 + i] = 1; + } + } + else{ + temp = 1; + count = 0; + for(i=0; i<templai[j]; i++){ + if(temp > (int)pSize[j]) temp = 1; + for(k=0; k<cumprod[j]; k++){ + subv[temp1 + count] = temp; + count++; + } + temp++; + } + } + } + free(cumprod); + free(templai); + } + + count = 0; + for(j=0; j<nCol; j++){ + temp1 = j * nRow; + for(i=0; i<nnRow; i++){ + start = (int)pNdx[i] - 1; + pr[count] = subv[temp1 + start]; + count++; + } + } + free(subv); +} + + + + + + diff --git a/sourcecodes/bnt-master/KPMtools/ind2subvKPM.m b/sourcecodes/bnt-master/KPMtools/ind2subvKPM.m new file mode 100644 index 00000000..da178c7b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/ind2subvKPM.m @@ -0,0 +1,57 @@ +function sub = ind2subvKPM(siz, ndx) +% IND2SUBV Like the built-in ind2sub, but returns the answer as a row vector. +% sub = ind2subv(siz, ndx) +% +% siz and ndx can be row or column vectors. +% sub will be of size length(ndx) * length(siz). +% +% Example +% ind2subv([2 2 2], 1:8) returns +% [1 1 1 +% 2 1 1 +% ... +% 2 2 2] +% That is, the leftmost digit toggle fastest. +% +% See also SUBV2IND + +n = length(siz); + + +if n==0 + sub = ndx; + return; +end + +if all(siz==2) + sub = dec2bitv(ndx-1, n); + sub = sub(:,n:-1:1)+1; + return; +end + +cp = [1 cumprod(siz(:)')]; +ndx = ndx(:) - 1; +sub = zeros(length(ndx), n); +for i = n:-1:1 % i'th digit + sub(:,i) = floor(ndx/cp(i))+1; + ndx = rem(ndx,cp(i)); +end + + + +%%%%%%%%%% + +function bits = dec2bitv(d,n) +% DEC2BITV Convert a decimal integer to a bit vector. +% bits = dec2bitv(d,n) is just like the built-in dec2bin, except the answer is a vector, not a string. +% n is an optional minimum length on the bit vector. +% If d is a vector, each row of the output array will be a bit vector. + + +if (nargin<2) + n=1; % Need at least one digit even for 0. +end +d = d(:); + +[f,e]=log2(max(d)); % How many digits do we need to represent the numbers? +bits=rem(floor(d*pow2(1-max(n,e):0)),2); diff --git a/sourcecodes/bnt-master/KPMtools/ind2subvMinka.m b/sourcecodes/bnt-master/KPMtools/ind2subvMinka.m new file mode 100644 index 00000000..4f2bcbef --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/ind2subvMinka.m @@ -0,0 +1,23 @@ +function sub = ind2subvMinka(siz,index) +%IND2SUBV Subscript vector from linear index. +% IND2SUBV(SIZ,IND) returns a vector of the equivalent subscript values +% corresponding to a single index into an array of size SIZ. +% If IND is a vector, then the result is a matrix, with subscript vectors +% as rows. + +% Written by Tom Minka +% (c) Microsoft Corporation. All rights reserved. + +n = length(siz); +if n==0, sub = index; return; end % added by KPM 17 Nov 07 +cum_size = cumprod(siz(:)'); +prev_cum_size = [1 cum_size(1:end-1)]; +index = index(:) - 1; +sub = rem(repmat(index,1,n),repmat(cum_size,length(index),1)); +sub = floor(sub ./ repmat(prev_cum_size,length(index),1))+1; + +% slow way +%for dim = n:-1:1 +% sub(:,dim) = floor(index/cum_size(dim))+1; +% index = rem(index,cum_size(dim)); +%end diff --git a/sourcecodes/bnt-master/KPMtools/ind2subvTest.m b/sourcecodes/bnt-master/KPMtools/ind2subvTest.m new file mode 100644 index 00000000..53312a3b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/ind2subvTest.m @@ -0,0 +1,10 @@ +function sub = ind2subvTest(siz,index) +%IND2SUBV Subscript vector from linear index. +% IND2SUBV(SIZ,IND) returns a vector of the equivalent subscript values +% corresponding to a single index into an array of size SIZ. +% If IND is a vector, then the result is a matrix, with subscript vectors +% as rows. + +sub = ind2subvMinka(siz, index); +subKPM = ind2subvKPM(siz, index); +assert(isequal(sub, subKPM)) diff --git a/sourcecodes/bnt-master/KPMtools/initFigures.m b/sourcecodes/bnt-master/KPMtools/initFigures.m new file mode 100644 index 00000000..6161b50e --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/initFigures.m @@ -0,0 +1,48 @@ +% initFigures +% Position 6 figures on the edges of the screen. +% [xmin ymin w h] where (0,0) = bottom left +% Numbers assume screen resolution is 1024 x 1280 + +global FIGNUM NUMFIGS +FIGNUM = 1; NUMFIGS = 6; + +screenMain = true; % set to false if initializing figures for second screen +%screenMain = false; + +if screenMain + xoff = 0; +else + %xoff = 1280; + xoff = -1280; +end + +% 2 x 3 design +w = 400; h = 300; +xs = [10 450 875] + xoff; +ys = [650 40]; + +if 0 +% 3x3 design +w = 350; h = 250; +xs = [10 380 750]+xoff; +ys = [700 350 10]; +end + + +Nfigs = length(xs)*length(ys); +if screenMain + fig = 1; +else + fig = Nfigs + 1; +end + +for yi=1:length(ys) + for xi=1:length(xs) + figure(fig); + set(gcf, 'position', [xs(xi) ys(yi) w h]); + fig = fig + 1; + end +end + +% To plot something on the next available figure (with wrap around), use +% sfigure(FIGNUM); clf; FIGNUM = wrap(FIGNUM+1, NUMFIGS); diff --git a/sourcecodes/bnt-master/KPMtools/installC_KPMtools.m b/sourcecodes/bnt-master/KPMtools/installC_KPMtools.m new file mode 100644 index 00000000..b09271af --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/installC_KPMtools.m @@ -0,0 +1,9 @@ +mex ind2subv.c +mex subv2ind.c +mex normalise.c +mex -c mexutil.c +if ~isunix + mex repmatC.c mexutil.obj +else + mex repmatC.c mexutil.o +end diff --git a/sourcecodes/bnt-master/KPMtools/is_psd.m b/sourcecodes/bnt-master/KPMtools/is_psd.m new file mode 100644 index 00000000..ff3baa54 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/is_psd.m @@ -0,0 +1,11 @@ +function b = positive_semidefinite(M) +% +% Return true iff v M v' >= 0 for any vector v. +% We do this by checking that all the eigenvalues are non-negative. + +E = eig(M); +if length(find(E>=0)) == length(E) + b = 1; +else + b = 0; +end diff --git a/sourcecodes/bnt-master/KPMtools/is_stochastic.m b/sourcecodes/bnt-master/KPMtools/is_stochastic.m new file mode 100644 index 00000000..4169f2cd --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/is_stochastic.m @@ -0,0 +1,5 @@ +function p = is_stochastic(T) +% IS_STOCHASTIC Is the argument a stochastic matrix, i.e., the sum over the last dimension is 1. +% p = is_stochastic(T) + +p = approxeq(T, mk_stochastic(T)); diff --git a/sourcecodes/bnt-master/KPMtools/isemptycell.m b/sourcecodes/bnt-master/KPMtools/isemptycell.m new file mode 100644 index 00000000..a8e5f943 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/isemptycell.m @@ -0,0 +1,16 @@ +function E = isemptycell(C) +% ISEMPTYCELL Apply the isempty function to each element of a cell array +% E = isemptycell(C) +% +% This is equivalent to E = cellfun('isempty', C), +% where cellfun is a function built-in to matlab version 5.3 or newer. + +if 0 % all(version('-release') >= 12) + E = cellfun('isempty', C); +else + E = zeros(size(C)); + for i=1:prod(size(C)) + E(i) = isempty(C{i}); + end + E = logical(E); +end diff --git a/sourcecodes/bnt-master/KPMtools/isequalKPM.m b/sourcecodes/bnt-master/KPMtools/isequalKPM.m new file mode 100644 index 00000000..2a6a2587 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/isequalKPM.m @@ -0,0 +1,7 @@ +function p = isequalKPM(a,b) + +if isempty(a) & isempty(b) + p = 1; +else + p = isequal(a,b); +end diff --git a/sourcecodes/bnt-master/KPMtools/isposdef.m b/sourcecodes/bnt-master/KPMtools/isposdef.m new file mode 100644 index 00000000..56f61967 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/isposdef.m @@ -0,0 +1,9 @@ +function b = isposdef(a) +% ISPOSDEF Test for positive definite matrix. +% ISPOSDEF(A) returns 1 if A is positive definite, 0 otherwise. +% Using chol is much more efficient than computing eigenvectors. + +% From Tom Minka's lightspeed toolbox + +[R,p] = chol(a); +b = (p == 0); diff --git a/sourcecodes/bnt-master/KPMtools/isscalarBNT.m b/sourcecodes/bnt-master/KPMtools/isscalarBNT.m new file mode 100644 index 00000000..557d169d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/isscalarBNT.m @@ -0,0 +1,5 @@ +function p = isscalarBNT(v) +% ISSCALAR Returns 1 if all dimensions have size 1. +% p = isscalar(v) + +p = (prod(size(v))==1); diff --git a/sourcecodes/bnt-master/KPMtools/isvectorBNT.m b/sourcecodes/bnt-master/KPMtools/isvectorBNT.m new file mode 100644 index 00000000..5bb367a6 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/isvectorBNT.m @@ -0,0 +1,9 @@ +function p = isvectorBNT(v) +% ISVECTOR Returns 1 if all but one dimension have size 1. +% p = isvector(v) +% +% Example: isvector(rand(1,2,1)) = 1, isvector(rand(2,2)) = 0. + +s=size(v); +p = (ndims(v)<=2) & (s(1) == 1 | s(2) == 1); +%p = sum( size(v) > 1) <= 1; % Peter Acklam's solution diff --git a/sourcecodes/bnt-master/KPMtools/junk.c b/sourcecodes/bnt-master/KPMtools/junk.c new file mode 100644 index 00000000..13624021 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/junk.c @@ -0,0 +1,67 @@ + + m = mxGetM(prhs[0]); + n = mxGetN(prhs[0]); + pr = mxGetPr(prhs[0]); + pi = mxGetPi(prhs[0]); + cmplx = (pi == NULL ? 0 : 1); + + /* Allocate space for sparse matrix. + * NOTE: Assume at most 20% of the data is sparse. Use ceil + * to cause it to round up. + */ + + percent_sparse = 0.2; + nzmax = (int)ceil((double)m*(double)n*percent_sparse); + + plhs[0] = mxCreateSparse(m,n,nzmax,cmplx); + sr = mxGetPr(plhs[0]); + si = mxGetPi(plhs[0]); + irs = mxGetIr(plhs[0]); + jcs = mxGetJc(plhs[0]); + + /* Copy nonzeros. */ + k = 0; + isfull = 0; + for (j = 0; (j < n); j++) { + int i; + jcs[j] = k; + for (i = 0; (i < m); i++) { + if (IsNonZero(pr[i]) || (cmplx && IsNonZero(pi[i]))) { + + /* Check to see if non-zero element will fit in + * allocated output array. If not, increase + * percent_sparse by 10%, recalculate nzmax, and augment + * the sparse array. + */ + if (k >= nzmax) { + int oldnzmax = nzmax; + percent_sparse += 0.1; + nzmax = (int)ceil((double)m*(double)n*percent_sparse); + + /* Make sure nzmax increases atleast by 1. */ + if (oldnzmax == nzmax) + nzmax++; + + mxSetNzmax(plhs[0], nzmax); + mxSetPr(plhs[0], mxRealloc(sr, nzmax*sizeof(double))); + if (si != NULL) + mxSetPi(plhs[0], mxRealloc(si, nzmax*sizeof(double))); + mxSetIr(plhs[0], mxRealloc(irs, nzmax*sizeof(int))); + + sr = mxGetPr(plhs[0]); + si = mxGetPi(plhs[0]); + irs = mxGetIr(plhs[0]); + } + sr[k] = pr[i]; + if (cmplx) { + si[k] = pi[i]; + } + irs[k] = i; + k++; + } + } + pr += m; + pi += m; + } + jcs[n] = k; +} diff --git a/sourcecodes/bnt-master/KPMtools/loadcell.m b/sourcecodes/bnt-master/KPMtools/loadcell.m new file mode 100644 index 00000000..85691854 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/loadcell.m @@ -0,0 +1,153 @@ +function [lc,dflag,dattype]=loadcell(fname,delim,exclusions,options); +%function [lc,dflag,numdata]=loadcell(fname,delim,exclusions); +% +% loadcell loads a cell array with character delimited +% data, which can have variable length lines and content. +% Numeric values are converted from string to double +% unless options is a string containing 'string'. +% +% loadcell is for use with small datasets. It is not optimised +% for large datasets. +% +% fname is the filename to be loaded +% +% delim is/are the relevant delimiter(s). If char(10) is included +% newlines are simply treated as delimiters and a 1-d array is created. +% +% exclusions are the set of characters to be treated as paired +% braces: line ends or delimiters within braces are ignored. +% braces are single characters and any brace can pair with +% any other brace: no type pair checking is done. +% +% options can be omitted or can contain 'string' if no numeric +% conversion is required, 'single' if multiple adjacent seperators +% should not be treated as one, 'free' if all linefeeds should be stripped +% first and 'empty2num' if empty fields are to be treated as numeric +% zeros rather than an empty character set. Combine options using +% concatenation. +% +% lc is a cell array containing the loaded data. +% +% dflag is a set of flags denoting the (i,j) values where data was entered +% dflag(i,j)=1 implies lc(i,j) was loaded from the data, and not just set +% to empty, say, by default. +% +% numdata is an array numdata(i,j)=NaN implies +% lc(i,j) is a string, otherwise it stores the number at i,j. +% This will occur regardless of whether the 'string' option is set. +% +% lc will return -1 if the file is not found or could not be +% opened. +% +% Hint: numdata+(1/dflag-1) provides a concise descriptor for the numeric data +% Inf=not loaded +% NaN=was string or empty set. +% otherwise numeric +% +% EXAMPLE +% +%[a,b]=loadcell('resultsfile',[',' char(9)],'"','single-string'); +% will load file 'resultsfile' into variable a, treating any of tab or +% comma as delimiters. Delimiters or carriage returns lying +% between two double inverted commas will be ignored. Two adjacent delimiters +% will count twice, and all data will be kept as a string. +% +% Note: in space-separated data 'single' would generally be omitted, +% wheras in comma-seperated data it would be included. +% +% Note the exclusion characters will remain in the final data, and any data +% contained within or containing exclusion characters will not be +% converted to numerics. +% +% (c) Amos Storkey 2002 +% v b160702 + +% MATLAB is incapable of loading variable length lines or variable type values +% with a whole file command under the standard library sets. This mfile +% fills that gap. +if (nargin<4) + options=' '; +end; +dflag = []; +%Open file +fid=fopen(fname,'rt'); +%Cannot open: return -1 +if (fid<0) + lc=-1; +else + fullfile=fread(fid,'uchar=>char')'; + %Strip LF if free is set + if ~isempty(findstr(options,'free')) + fullfile=strrep(fullfile,char(10),''); + end; + %Find all delimiters + delimpos=[]; + for s=1:length(delim) + delimpos=[delimpos find(fullfile==delim(s))]; + end + %Find all eol + endpos=find(fullfile==char(10)); + endpos=setdiff(endpos,delimpos); + %find all exclusions + xclpos=[]; + for s=1:length(exclusions); + xclpos=[xclpos find(fullfile==exclusions(s))]; + end + sort(xclpos); + xclpos=[xclpos(1:2:end-1);xclpos(2:2:end)]; + %Combine eol and delimiters + jointpos=union(delimpos,endpos); + t=1; + %Remove delim/eol within exclusion pairs + removedelim=[]; + for s=1:length(jointpos) + if any((jointpos(s)>xclpos(1,:)) & (jointpos(s)<xclpos(2,:))) + removedelim(t)=jointpos(s); + t=t+1; + end; + + end + %and add start point + jointpos=[0 setdiff(jointpos,removedelim)]; + i=1; + j=1; + posind=1; + multflag=isempty(findstr(options,'single')); + stringflag=~isempty(findstr(options,'string')); + emptnum=~isempty(findstr(options,'empty2num')); + %Run through + while (posind<(length(jointpos))) + %Get current field + tempstr=fullfile(jointpos(posind)+1:jointpos(posind+1)-1); + %If empty only continue if adjacent delim count. + if ~(isempty(tempstr) & multflag); + %This ij is set + dflag(i,j)=1; + %Convert to num + tempno=str2double([tempstr]); + %If emptystring convert to zero if emptnum set + if (isempty(tempstr) & emptnum) + tempno=0; + end; + %Set dattype to no (or NaN if not a num + dattype(i,j)=tempno; + %If NaN set lc to string else to num if stringflag not set + if (isnan(tempno) | stringflag) + lc{i,j}=tempstr; + else + lc{i,j}=tempno; + end; + %Next j + j=j+1; + end; + %If eol inc i and reset j + if ismember(jointpos(posind+1),endpos) + i=i+1; + j=1; + end; + %Inc to next delim + posind=posind+1; + end; +end; +%Logicalise dflag +dflag=logical(dflag); diff --git a/sourcecodes/bnt-master/KPMtools/logb.m b/sourcecodes/bnt-master/KPMtools/logb.m new file mode 100644 index 00000000..aa77ddb9 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/logb.m @@ -0,0 +1,5 @@ +function x = logb(y, base) +% logb - logarithm to base b +% function x = logb(y, base) + +x = log(y) ./ log(base); diff --git a/sourcecodes/bnt-master/KPMtools/logdet.m b/sourcecodes/bnt-master/KPMtools/logdet.m new file mode 100644 index 00000000..cfff98d2 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/logdet.m @@ -0,0 +1,8 @@ +function y = logdet(A) +% log(det(A)) where A is positive-definite. +% This is faster and more stable than using log(det(A)). + +% From Tom Minka's lightspeed toolbox + +U = chol(A); +y = 2*sum(log(diag(U))); diff --git a/sourcecodes/bnt-master/KPMtools/logsum.m b/sourcecodes/bnt-master/KPMtools/logsum.m new file mode 100644 index 00000000..1d8ae457 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/logsum.m @@ -0,0 +1,28 @@ +function y=logsum(x,d) +%LOGSUM logsum(x,d)=log(sum(exp(x),d)) +% d gives dimension to sum along + +% Copyright (C) Mike Brookes 1998 +% +% Last modified Mon Oct 12 15:47:25 1998 +% +% VOICEBOX is a MATLAB toolbox for speech processing. Home page is at +% http://www.ee.ic.ac.uk/hp/staff/dmb/voicebox/voicebox.html +% + +if nargin==1 + d=[find(size(x)-1) 1]; + d=d(1); +end +n=size(x,d); +if n<=1, y=x; return; end +s=size(x); +p=[d:ndims(x) 1:d-1]; +z=reshape(permute(x,p),n,prod(s)/n); + +y=max(z); +y=y+log(sum(exp(z-y(ones(n,1),:)))); + +s(d)=1; +y=ipermute(reshape(y,s(p)),p); + diff --git a/sourcecodes/bnt-master/KPMtools/logsum_simple.m b/sourcecodes/bnt-master/KPMtools/logsum_simple.m new file mode 100644 index 00000000..9af56669 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/logsum_simple.m @@ -0,0 +1,23 @@ +function result = logsum(logv) + +len = length(logv); +if (len<2); + error('Subroutine logsum cannot sum less than 2 terms.'); +end; + +% First two terms +if (logv(2)<logv(1)), + result = logv(1) + log( 1 + exp( logv(2)-logv(1) ) ); +else, + result = logv(2) + log( 1 + exp( logv(1)-logv(2) ) ); +end; + +% Remaining terms +for (i=3:len), + term = logv(i); + if (result<term), + result = term + log( 1 + exp( result-term ) ); + else, + result = result + log( 1 + exp( term-result ) ); + end; +end diff --git a/sourcecodes/bnt-master/KPMtools/logsum_test.m b/sourcecodes/bnt-master/KPMtools/logsum_test.m new file mode 100644 index 00000000..d7c701db --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/logsum_test.m @@ -0,0 +1,6 @@ +p1 = log(1e-5); +p2 = log(5*1e-6); +p3 = log(sum(exp([p1 p2]))) +p4 = logsumexp([p1 p2],2) +p5 = logsum([p1 p2]) +p6 = logsum([p1 p2]) diff --git a/sourcecodes/bnt-master/KPMtools/logsumexp.m b/sourcecodes/bnt-master/KPMtools/logsumexp.m new file mode 100644 index 00000000..b639cbb2 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/logsumexp.m @@ -0,0 +1,24 @@ +function s = logsumexp(a, dim) +% Returns log(sum(exp(a),dim)) while avoiding numerical underflow. +% Default is dim = 1 (rows) or dim=2 for a row vector +% logsumexp(a, 2) will sum across columns instead of rows + +% Written by Tom Minka, modified by Kevin Murphy + +if nargin < 2 + dim = 1; + if ndims(a) <= 2 & size(a,1)==1 + dim = 2; + end +end + +% subtract the largest in each column +[y, i] = max(a,[],dim); +dims = ones(1,ndims(a)); +dims(dim) = size(a,dim); +a = a - repmat(y, dims); +s = y + log(sum(exp(a),dim)); +%i = find(~finite(y)); +%if ~isempty(i) +% s(i) = y(i); +%end diff --git a/sourcecodes/bnt-master/KPMtools/logsumexpv.m b/sourcecodes/bnt-master/KPMtools/logsumexpv.m new file mode 100644 index 00000000..d8e4d8a7 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/logsumexpv.m @@ -0,0 +1,15 @@ +function s = logsumexpv(a) +% Returns log(sum(exp(a))) while avoiding numerical underflow. +% +% e.g., log(e^a1 + e^a2) = a1 + log(1 + e^(a2-a1)) if a1>a2 +% If a1 ~ a2, and a1>a2, then e^(a2-a1) is exp(small negative number), +% which can be computed without underflow. + +% Same as logsumexp, except we assume a is a vector. +% This avoids a call to repmat, which takes 50% of the time! + +a = a(:)'; % make row vector +m = max(a); +b = a - m*ones(1,length(a)); +s = m + log(sum(exp(b))); + diff --git a/sourcecodes/bnt-master/KPMtools/mahal2conf.m b/sourcecodes/bnt-master/KPMtools/mahal2conf.m new file mode 100644 index 00000000..e5535748 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mahal2conf.m @@ -0,0 +1,60 @@ +% MAHAL2CONF - Translates a Mahalanobis distance into a confidence +% interval. Consider a multivariate Gaussian +% distribution of the form +% +% p(x) = 1/sqrt((2 * pi)^d * det(C)) * exp((-1/2) * MD(x, m, inv(C))) +% +% where MD(x, m, P) is the Mahalanobis distance from x +% to m under P: +% +% MD(x, m, P) = (x - m) * P * (x - m)' +% +% A particular Mahalanobis distance k identifies an +% ellipsoid centered at the mean of the distribution. +% The confidence interval associated with this ellipsoid +% is the probability mass enclosed by it. +% +% If X is an d dimensional Gaussian-distributed vector, +% then the Mahalanobis distance of X is distributed +% according to the Chi-squared distribution with d +% degrees of freedom. Thus, the confidence interval is +% determined by integrating the chi squared distribution +% up to the Mahalanobis distance of the measurement. +% +% Usage: +% +% c = mahal2conf(m, d); +% +% Inputs: +% +% m - the Mahalanobis radius of the ellipsoid +% d - the number of dimensions of the Gaussian distribution +% +% Outputs: +% +% c - the confidence interval, i.e., the fraction of +% probability mass enclosed by the ellipsoid with the +% supplied Mahalanobis distance +% +% See also: CONF2MAHAL + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% +function c = mahal2conf(m, d) + +c = chi2cdf(m, d); \ No newline at end of file diff --git a/sourcecodes/bnt-master/KPMtools/marg_table.m b/sourcecodes/bnt-master/KPMtools/marg_table.m new file mode 100644 index 00000000..0f1e5be5 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/marg_table.m @@ -0,0 +1,27 @@ +function smallT = marg_table(bigT, bigdom, bigsz, onto, maximize) +% MARG_TABLE Marginalize a table +% smallT = marg_table(bigT, bigdom, bigsz, onto, maximize) + +if nargin < 5, maximize = 0; end + + +smallT = myreshape(bigT, bigsz); % make sure it is a multi-dim array +sum_over = mysetdiff(bigdom, onto); +ndx = find_equiv_posns(sum_over, bigdom); +if maximize + for i=1:length(ndx) + smallT = max(smallT, [], ndx(i)); + end +else + for i=1:length(ndx) + smallT = sum(smallT, ndx(i)); + end +end + + +ns = zeros(1, max(bigdom)); +%ns(bigdom) = mysize(bigT); % ignores trailing dimensions of size 1 +ns(bigdom) = bigsz; + +smallT = squeeze(smallT); % remove all dimensions of size 1 +smallT = myreshape(smallT, ns(onto)); % put back relevant dims of size 1 diff --git a/sourcecodes/bnt-master/KPMtools/marginalize_table.m b/sourcecodes/bnt-master/KPMtools/marginalize_table.m new file mode 100644 index 00000000..adc5443c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/marginalize_table.m @@ -0,0 +1,50 @@ +function smallT = marginalize_table(bigT, bigdom, bigsz, onto, maximize) +% MARG_TABLE Marginalize a table +% function smallT = marginalize_table(bigT, bigdom, bigsz, onto, maximize) + +% Like marg_table in BNT, except we do not assume the domains are sorted + +if nargin < 5, maximize = 0; end + + +smallT = myreshape(bigT, bigsz); % make sure it is a multi-dim array +sum_over = mysetdiff(bigdom, onto); +ndx = find_equiv_posns(sum_over, bigdom); +if maximize + for i=1:length(ndx) + smallT = max(smallT, [], ndx(i)); + end +else + for i=1:length(ndx) + smallT = sum(smallT, ndx(i)); + end +end + + +ns = zeros(1, max(bigdom)); +%ns(bigdom) = mysize(bigT); % ignores trailing dimensions of size 1 +ns(bigdom) = bigsz; + +% If onto has a different ordering than bigdom, the following +% will produce the wrong results + +%smallT = squeeze(smallT); % remove all dimensions of size 1 +%smallT = myreshape(smallT, ns(onto)); % put back relevant dims of size 1 + +% so permute dimensions to match desired ordering (as specified by onto) + + +% like find_equiv_posns, but keeps ordering +outdom = [onto sum_over]; +for i=1:length(outdom) + j = find(bigdom==outdom(i)); + match(i) = j; +end +outdom = [onto sum_over]; +for i=1:length(outdom) + j = find(bigdom==outdom(i)); + match(i) = j; +end +if match ~= 1 + smallT = permute(smallT, match); +end diff --git a/sourcecodes/bnt-master/KPMtools/matprint.m b/sourcecodes/bnt-master/KPMtools/matprint.m new file mode 100644 index 00000000..e05c5f40 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/matprint.m @@ -0,0 +1,36 @@ +% MATPRINT - prints a matrix with specified format string +% +% Usage: matprint(a, fmt, fid) +% +% a - Matrix to be printed. +% fmt - C style format string to use for each value. +% fid - Optional file id. +% +% Eg. matprint(a,'%3.1f') will print each entry to 1 decimal place + +% Peter Kovesi +% School of Computer Science & Software Engineering +% The University of Western Australia +% pk @ csse uwa edu au +% http://www.csse.uwa.edu.au/~pk +% +% March 2002 + +function matprint(a, fmt, fid) + + if nargin < 3 + fid = 1; + end + + [rows,cols] = size(a); + + % Construct a format string for each row of the matrix consisting of + % 'cols' copies of the number formating specification + fmtstr = []; + for c = 1:cols + fmtstr = [fmtstr, ' ', fmt]; + end + fmtstr = [fmtstr '\n']; % Add a line feed + + fprintf(fid, fmtstr, a'); % Print the transpose of the matrix because + % fprintf runs down the columns of a matrix. \ No newline at end of file diff --git a/sourcecodes/bnt-master/KPMtools/max_mult.c b/sourcecodes/bnt-master/KPMtools/max_mult.c new file mode 100644 index 00000000..204fd956 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/max_mult.c @@ -0,0 +1,46 @@ +/* C mex version of max_mult.m in BPMRF2 directory */ +/* gcc -Wall -I/mit/matlab_v6.5/distrib/bin/glnx86 -c max_mult.c */ + +#include <math.h> +#include "mex.h" + +void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) +{ + int rows,cols,common,m,n,p; + double y1, y2; + double *arr1, *arr2, *arr3; + + + if (nrhs!=2 || nlhs>1) + mexErrMsgTxt("max_mult requires two inputs and one output"); + if (mxIsChar(prhs[0]) || mxIsClass(prhs[0], "sparse") || mxIsComplex(prhs[0]) + || mxIsChar(prhs[1]) || mxIsClass(prhs[1], "sparse") || mxIsComplex(prhs[1])) + mexErrMsgTxt("Inputs must be real, full, and nonstring"); + if (mxGetN(prhs[0])!=mxGetM(prhs[1])) + mexErrMsgTxt("The number of columns of A must be the same as the number of rows of x"); + + + arr1=mxGetPr(prhs[0]); + arr2=mxGetPr(prhs[1]); + p=mxGetN(prhs[0]); + m=mxGetM(prhs[0]); + n=mxGetN(prhs[1]); + plhs[0]=mxCreateDoubleMatrix(m, n, mxREAL); + arr3=mxMalloc(m*n*sizeof(double)); + + for (rows=0; rows<m ; rows++) + for (cols=0; cols<n ; cols++) + { + y1=arr1[rows]*arr2[cols*p]; + for (common=1; common<p; common++) + { + y2=arr1[rows+common*m]*arr2[common+cols*p]; + if (y2>y1) + y1=y2; + } + arr3[rows+cols*m]=y1; + } + + mxSetPr(plhs[0], arr3); + +} diff --git a/sourcecodes/bnt-master/KPMtools/max_mult.m b/sourcecodes/bnt-master/KPMtools/max_mult.m new file mode 100644 index 00000000..fab37e3a --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/max_mult.m @@ -0,0 +1,21 @@ +function y=max_mult(A,x) +% MAX_MULT Like matrix multiplication, but sum gets replaced by max +% function y=max_mult(A,x) y(i) = max_j A(i,j) x(j) + +%X=ones(size(A,1),1) * x(:)'; % X(j,i) = x(i) +%y=max(A.*X, [], 2); + +% This is faster +if size(x,2)==1 + X=x*ones(1,size(A,1)); % X(i,j) = x(i) + y=max(A'.*X)'; +else +%this works for arbitrarily sized A and x (but is ugly, and slower than above) + X=repmat(x, [1 1 size(A,1)]); + B=repmat(A, [1 1 size(x,2)]); + C=permute(B,[2 3 1]); + y=permute(max(C.*X),[3 2 1]); +% this is even slower, as is using squeeze instead of permute +% Y=permute(X, [3 1 2]); +% y=permute(max(Y.*B, [], 2), [1 3 2]); +end diff --git a/sourcecodes/bnt-master/KPMtools/mexutil.c b/sourcecodes/bnt-master/KPMtools/mexutil.c new file mode 100644 index 00000000..b2bd3e7d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mexutil.c @@ -0,0 +1,43 @@ +#include "mexutil.h" + +/* Functions to create uninitialized arrays. */ + +mxArray *mxCreateNumericArrayE(int ndim, const int *dims, + mxClassID class, mxComplexity ComplexFlag) +{ + mxArray *a; + int i, *dims1 = mxMalloc(ndim*sizeof(int)); + size_t sz = 1; + for(i=0;i<ndim;i++) { + sz *= dims[i]; + dims1[i] = 1; + } + a = mxCreateNumericArray(ndim,dims1,class,ComplexFlag); + sz *= mxGetElementSize(a); + mxSetDimensions(a, dims, ndim); + mxFree(dims1); + mxSetData(a, mxRealloc(mxGetData(a), sz)); + if(ComplexFlag == mxCOMPLEX) { + mxSetPi(a, mxRealloc(mxGetPi(a),sz)); + } + return a; +} +mxArray *mxCreateNumericMatrixE(int m, int n, mxClassID class, + mxComplexity ComplexFlag) +{ + size_t sz = m*n*sizeof(double); + mxArray *a = mxCreateNumericMatrix(1, 1, class, ComplexFlag); + mxSetM(a,m); + mxSetN(a,n); + mxSetPr(a, mxRealloc(mxGetPr(a),sz)); + if(ComplexFlag == mxCOMPLEX) { + mxSetPi(a, mxRealloc(mxGetPi(a),sz)); + } + return a; +} +mxArray *mxCreateDoubleMatrixE(int m, int n, + mxComplexity ComplexFlag) +{ + return mxCreateNumericMatrixE(m,n,mxDOUBLE_CLASS,ComplexFlag); +} + diff --git a/sourcecodes/bnt-master/KPMtools/mexutil.h b/sourcecodes/bnt-master/KPMtools/mexutil.h new file mode 100644 index 00000000..683156da --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mexutil.h @@ -0,0 +1,8 @@ +#include "mex.h" + +mxArray *mxCreateNumericArrayE(int ndim, const int *dims, + mxClassID class, mxComplexity ComplexFlag); +mxArray *mxCreateNumericMatrixE(int m, int n, mxClassID class, + mxComplexity ComplexFlag); +mxArray *mxCreateDoubleMatrixE(int m, int n, + mxComplexity ComplexFlag); diff --git a/sourcecodes/bnt-master/KPMtools/mk_multi_index.m b/sourcecodes/bnt-master/KPMtools/mk_multi_index.m new file mode 100644 index 00000000..5cb86d5d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mk_multi_index.m @@ -0,0 +1,23 @@ +function index = mk_multi_index(n, dims, vals) +% MK_MULTI_INDEX Compute the indices of the submatrix where dims(i)=vals(i). +% index = mk_multi_index(n, dims, vals) +% +% Example: +% index = mk_multi_index(3, [1 3], [3 2]) +% gives index = {3, ':', 2}, which will select out dim 1 = 3 and dim 3 = 2 +% So if A(:,:,1)=[1 2;3 4; 5 6]; A(:,:,2)=[7 8; 9 10; 11 12] +% then A(index{:}) = [11 12]: + +if n==0 + index = { 1 }; + return; +end + +index = cell(1,n); +for i=1:n + index{i} = ':'; +end +for i=1:length(dims) + index{dims(i)} = vals(i); +end + diff --git a/sourcecodes/bnt-master/KPMtools/mk_stochastic.m b/sourcecodes/bnt-master/KPMtools/mk_stochastic.m new file mode 100644 index 00000000..68aac6ab --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mk_stochastic.m @@ -0,0 +1,27 @@ +function [T,Z] = mk_stochastic(T) +% MK_STOCHASTIC Ensure the argument is a stochastic matrix, i.e., the sum over the last dimension is 1. +% [T,Z] = mk_stochastic(T) +% +% If T is a vector, it will sum to 1. +% If T is a matrix, each row will sum to 1. +% If T is a 3D array, then sum_k T(i,j,k) = 1 for all i,j. + +% Set zeros to 1 before dividing +% This is valid since S(j) = 0 iff T(i,j) = 0 for all j + +if (ndims(T)==2) && (size(T,1)==1 || size(T,2)==1) % isvector + [T,Z] = normalise(T); +elseif ndims(T)==2 % matrix + Z = sum(T,2); + S = Z + (Z==0); + norm = repmat(S, 1, size(T,2)); + T = T ./ norm; +else % multi-dimensional array + ns = size(T); + T = reshape(T, prod(ns(1:end-1)), ns(end)); + Z = sum(T,2); + S = Z + (Z==0); + norm = repmat(S, 1, ns(end)); + T = T ./ norm; + T = reshape(T, ns); +end diff --git a/sourcecodes/bnt-master/KPMtools/mkdirKPM.m b/sourcecodes/bnt-master/KPMtools/mkdirKPM.m new file mode 100644 index 00000000..56c50567 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mkdirKPM.m @@ -0,0 +1,24 @@ +function mkdirKPM(dname) +% function mkdirKPM(dname) +% If directory does not exist, make it +% +% mkdirKPM('foo\bar\baz') makes subdirectories bar and baz +% mkdirKPM('foo\bar\baz.txt') makes subdirectories bar + +% convert foo\bar\baz to pathstr=foo\bar, name=baz +% convert foo\bar\baz.txt to pathstr=foo\bar, name=baz +[pathstr, name, ext, versn] = fileparts(dname); +if ~isempty(ext) % we stripped off something after final period + % convert foo\bar to pathstr=foo, name=bar + % convert foo\bar.bad to pathstr=foo, name=bar.bad + [pathstr, name, ext, versn] = fileparts(pathstr); + name = sprintf('%s%s', name, ext); % in case there is a period in the directory name +end + +dname = fullfile(pathstr, name); +if ~exist(dname, 'dir') + %fprintf('mkdirKPM: making %s, %s \n', pathstr, name); + mkdir(pathstr, name) +else + %fprintf('mkdirKPM: %s already exists\n', dname) +end diff --git a/sourcecodes/bnt-master/KPMtools/montageKPM.m b/sourcecodes/bnt-master/KPMtools/montageKPM.m new file mode 100644 index 00000000..c0354d3c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/montageKPM.m @@ -0,0 +1,102 @@ +function h = montageKPM(arg) +% montageKPM is like the built-in montage, but assumes input is MxNxK or filenames +% +% Converts patches (y,x,i) into patches(y,x,1,i) +% Also, adds a black border aroudn them + +if iscell(arg) + h= montageFilenames(arg); +else + nr = size(arg,1); nc = size(arg,2); Npatches = size(arg,3); + patchesColor = reshape(arg, [nr nc 1 Npatches]); + patchesColor = patchesColor ./ max(patchesColor(:)); + + if 1 + %put a black border around them for display purposes + border = 5; + bgColor = ones(1,1,class(patchesColor)); + patchesColorBig = bgColor*ones(nr+2*border, nc+2*border, 1, Npatches, class(patchesColor)); + %patchesColorBig = zeros(nr+2*border, nc+2*border, 1, Npatches, class(patchesColor)); + patchesColorBig(border+1:end-border, border+1:end-border, :, :) = patchesColor; + else + patchesColorBig = patchesColor; + end + montage(patchesColorBig) + +end + +%%%%%%%%%%%%% + +function h = montageFilenames(filenames) + +%[nRows, nCols, nBands, nFrames] = size(a); + +% Estimate nMontageColumns and nMontageRows given the desired ratio of +% Columns to Rows to be one (square montage). +aspectRatio = 1; +nMontageCols = sqrt(aspectRatio * nRows * nFrames / nCols); + +% Make sure montage rows and columns are integers. The order in the adjustment +% matters because the montage image is created horizontally across columns. +nMontageCols = ceil(nMontageCols); +nMontageRows = ceil(nFrames / nMontageCols); + +% Create the montage image. +b = a(1,1); % to inherit type +b(1,1) = 0; % from a +b = repmat(b, [nMontageRows*nRows, nMontageCols*nCols, nBands, 1]); + +rows = 1 : nRows; +cols = 1 : nCols; + +for i = 0:nMontageRows-1 + for j = 0:nMontageCols-1, + k = j + i * nMontageCols + 1; + if k <= nFrames + b(rows + i * nRows, cols + j * nCols, :) = a(:,:,:,k); + else + break; + end + end +end + +if isempty(cm) + hh = imshow(b); +else + hh = imshow(b,cm); +end + +if nargout > 0 + h = hh; +end + +%-------------------------------------------------------------- +%Parse Inputs Function + +function [I,map] = parse_inputs(varargin) + +% initialize variables +map = []; + +iptchecknargin(1,2,nargin,mfilename); +iptcheckinput(varargin{1},{'uint8' 'double' 'uint16' 'logical' 'single' ... + 'int16'},{},mfilename, 'I, BW, or RGB',1); +I = varargin{1}; + +if nargin==2 + if isa(I,'int16') + eid = sprintf('Images:%s:invalidIndexedImage',mfilename); + msg1 = 'An indexed image can be uint8, uint16, double, single, or '; + msg2 = 'logical.'; + error(eid,'%s %s',msg1, msg2); + end + map = varargin{2}; + iptcheckinput(map,{'double'},{},mfilename,'MAP',1); + if ((size(map,1) == 1) && (prod(map) == numel(I))) + % MONTAGE(D,[M N P]) OBSOLETE + eid = sprintf('Images:%s:obsoleteSyntax',mfilename); + msg1 = 'MONTAGE(D,[M N P]) is an obsolete syntax.'; + msg2 = 'Use multidimensional arrays to represent multiframe images.'; + error(eid,'%s\n%s',msg1,msg2); + end +end diff --git a/sourcecodes/bnt-master/KPMtools/montageKPM2.m b/sourcecodes/bnt-master/KPMtools/montageKPM2.m new file mode 100644 index 00000000..1bd521a9 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/montageKPM2.m @@ -0,0 +1,69 @@ +function montageKPM2(data) +% data(y,x,b,f) or data(y,x,f) +% can be double - uses imagesc to display, not imshow +% based on imaqmontage + +if ndims(data)==3 + nr = size(data,1); nc = size(data,2); Npatches = size(data,3); Nbands = 1; + data = reshape(data, [nr nc Nbands Npatches]); +else + nr = size(data,1); nc = size(data,2); Nbands = size(data,3); Npatches = size(data,4); +end +nativeVal = data(1, 1); +dataOrig = data; + +%put a black border around them for display purposes +border = 5; +bgColor = min(data(:)); +%bgColor = max(data(:)); +data = bgColor*ones(nr+2*border, nc+2*border, Nbands, Npatches, class(data)); +data(border+1:end-border, border+1:end-border, :, :) = dataOrig; + +[width, height, bands, nFrames] = size(data); + +% Determine the number of axis rows and columns. +axCols = sqrt(nFrames); +if (axCols<1) + % In case we have a slim image. + axCols = 1; +end +axRows = nFrames/axCols; +if (ceil(axCols)-axCols) < (ceil(axRows)-axRows), + axCols = ceil(axCols); + axRows = ceil(nFrames/axCols); +else + axRows = ceil(axRows); + axCols = ceil(nFrames/axRows); +end + +% Size the storage to hold all frames. +storage = repmat(nativeVal, [axRows*width, axCols*height, bands, 1]); + +% Fill the storage up with data pixels. +rows = 1:width; +cols = 1:height; +for i=0:axRows-1, + for j=0:axCols-1, + k = j+i*axCols+1; + if k<=nFrames, + storage(rows+i*width, cols+j*height, :) = data(:,:,:,k); + else + break; + end + end +end + + +% Display the tiled frames nicely and +% pop the window forward. +im = imagesc(storage); + +ax = get(im, 'Parent'); +fig = get(ax, 'Parent'); +set(ax, 'XTick', [], 'YTick', []) +figure(fig) + +% If working with single band images, update the colormap. +if 0 % bands==1, + colormap(gray); +end diff --git a/sourcecodes/bnt-master/KPMtools/montageKPM3.m b/sourcecodes/bnt-master/KPMtools/montageKPM3.m new file mode 100644 index 00000000..fb2d540a --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/montageKPM3.m @@ -0,0 +1,5 @@ +function montageKPM3(data) +% data{f}(y,x,b) - each frame can have a different size (can can even be empty) + +data2 = cell2matPad(data); +montageKPM2(data2) diff --git a/sourcecodes/bnt-master/KPMtools/mult_by_table.m b/sourcecodes/bnt-master/KPMtools/mult_by_table.m new file mode 100644 index 00000000..a92e340f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mult_by_table.m @@ -0,0 +1,7 @@ +function bigT = mult_by_table(bigT, bigdom, bigsz, smallT, smalldom, smallsz) +% MULT_BY_TABLE +% bigT = mult_by_table(bigT, bigdom, bigsz, smallT, smalldom, smallsz) +% + +Ts = extend_domain_table(smallT, smalldom, smallsz, bigdom, bigsz); +bigT(:) = bigT(:) .* Ts(:); % must have bigT(:) on LHS to preserve shape diff --git a/sourcecodes/bnt-master/KPMtools/myintersect.m b/sourcecodes/bnt-master/KPMtools/myintersect.m new file mode 100644 index 00000000..c1886efb --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myintersect.m @@ -0,0 +1,28 @@ +function C = myintersect(A,B) +% MYINTERSECT Intersection of two sets of positive integers (much faster than built-in intersect) +% C = myintersect(A,B) + +A = A(:)'; B = B(:)'; + +if isempty(A) + ma = 0; +else + ma = max(A); +end + +if isempty(B) + mb = 0; +else + mb = max(B); +end + +if ma==0 || mb==0 + C = []; +else + %bits = sparse(1, max(ma,mb)); + bits = zeros(1, max(ma,mb)); + bits(A) = 1; + C = B(logical(bits(B))); +end + +%sum( bitget( bitand( cliquesb(i), cliquesb(j) ), 1:52 ) ); diff --git a/sourcecodes/bnt-master/KPMtools/myismember.m b/sourcecodes/bnt-master/KPMtools/myismember.m new file mode 100644 index 00000000..d339bb42 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myismember.m @@ -0,0 +1,18 @@ +function p = myismember(a,A) +% MYISMEMBER Is 'a' an element of a set of positive integers? (much faster than built-in ismember) +% p = myismember(a,A) + +%if isempty(A) | a < min(A) | a > max(A) % slow + +if length(A)==0 + p = 0; +elseif a < min(A) + p = 0; +elseif a > max(A) + p = 0; +else + bits = zeros(1, max(A)); + bits(A) = 1; + p = bits(a); +end +p = logical(p); diff --git a/sourcecodes/bnt-master/KPMtools/myismember.m~ b/sourcecodes/bnt-master/KPMtools/myismember.m~ new file mode 100644 index 00000000..6c93c11a --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myismember.m~ @@ -0,0 +1,17 @@ +function p = myismember(a,A) +% MYISMEMBER Is 'a' an element of a set of positive integers? (much faster than built-in ismember) +% p = myismember(a,A) + +%if isempty(A) | a < min(A) | a > max(A) % slow + +if length(A)==0 + p = 0; +elseif a < min(A) + p = 0; +elseif a > max(A) + p = 0; +else + bits = zeros(1, max(A)); + bits(A) = 1; + p = bits(a); +end diff --git a/sourcecodes/bnt-master/KPMtools/myones.m b/sourcecodes/bnt-master/KPMtools/myones.m new file mode 100644 index 00000000..28d18042 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myones.m @@ -0,0 +1,11 @@ +function T = myones(sizes) +% MYONES Like the built-in ones, except myones(k) produces a k*1 vector instead of a k*k matrix, +% T = myones(sizes) + +if length(sizes)==0 + T = 1; +elseif length(sizes)==1 + T = ones(sizes, 1); +else + T = ones(sizes(:)'); +end diff --git a/sourcecodes/bnt-master/KPMtools/myplot.m b/sourcecodes/bnt-master/KPMtools/myplot.m new file mode 100644 index 00000000..0698e485 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myplot.m @@ -0,0 +1,7 @@ +colors = ['r' 'b' 'k' 'g' 'c' 'y' 'm' ... + 'r' 'b' 'k' 'g' 'c' 'y' 'm']; +symbols = ['o' 'x' 's' '>' '<' '^' 'v' ... + '*' 'p' 'h' '+' 'd' 'o' 'x']; +for i=1:length(colors) + styles{i} = sprintf('-%s%s', colors(i), symbols(i)); +end diff --git a/sourcecodes/bnt-master/KPMtools/myrand.m b/sourcecodes/bnt-master/KPMtools/myrand.m new file mode 100644 index 00000000..836b854b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myrand.m @@ -0,0 +1,12 @@ +function T = myrand(sizes) +% MYRAND Like the built-in rand, except myrand(k) produces a k*1 vector instead of a k*k matrix, +% T = myrand(sizes) + +if length(sizes)==0 + warning('myrand[]'); + T = rand(1,1); +elseif length(sizes)==1 + T = rand(sizes, 1); +else + T = rand(sizes); +end diff --git a/sourcecodes/bnt-master/KPMtools/myrepmat.m b/sourcecodes/bnt-master/KPMtools/myrepmat.m new file mode 100644 index 00000000..830dbf41 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myrepmat.m @@ -0,0 +1,9 @@ +function T = myrepmat(T, sizes) +% MYREPMAT Like the built-in repmat, except myrepmat(T,n) == repmat(T,[n 1]) +% T = myrepmat(T, sizes) + +if length(sizes)==1 + T = repmat(T, [sizes 1]); +else + T = repmat(T, sizes(:)'); +end diff --git a/sourcecodes/bnt-master/KPMtools/myreshape.m b/sourcecodes/bnt-master/KPMtools/myreshape.m new file mode 100644 index 00000000..9613f1dc --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myreshape.m @@ -0,0 +1,11 @@ +function T = myreshape(T, sizes) +% MYRESHAPE Like the built-in reshape, except myreshape(T,n) == reshape(T,[n 1]) +% T = myreshape(T, sizes) + +if length(sizes)==0 + return; +elseif length(sizes)==1 + T = reshape(T, [sizes 1]); +else + T = reshape(T, sizes(:)'); +end diff --git a/sourcecodes/bnt-master/KPMtools/mysetdiff.m b/sourcecodes/bnt-master/KPMtools/mysetdiff.m new file mode 100644 index 00000000..fb647f4e --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mysetdiff.m @@ -0,0 +1,19 @@ +function C = mysetdiff(A,B) +% MYSETDIFF Set difference of two sets of positive integers (much faster than built-in setdiff) +% C = mysetdiff(A,B) +% C = A \ B = { things in A that are not in B } +% +% Original by Kevin Murphy, modified by Leon Peshkin + +if isempty(A) + C = []; + return; +elseif isempty(B) + C = A; + return; +else % both non-empty + bits = zeros(1, max(max(A), max(B))); + bits(A) = 1; + bits(B) = 0; + C = A(logical(bits(A))); +end diff --git a/sourcecodes/bnt-master/KPMtools/mysize.m b/sourcecodes/bnt-master/KPMtools/mysize.m new file mode 100644 index 00000000..40cb659c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mysize.m @@ -0,0 +1,16 @@ +function sz = mysize(M) +% MYSIZE Like the built-in size, except it returns n if M is a vector of length n, and 1 if M is a scalar. +% sz = mysize(M) +% +% The behavior is best explained by examples +% - M = rand(1,1), mysize(M) = 1, size(M) = [1 1] +% - M = rand(2,1), mysize(M) = 2, size(M) = [2 1] +% - M = rand(1,2), mysize(M) = 2, size(M) = [1 2] +% - M = rand(2,2,1), mysize(M) = [2 2], size(M) = [2 2] +% - M = rand(1,2,1), mysize(M) = 2, size(M) = [1 2] + +if isvectorBNT(M) + sz = length(M); +else + sz = size(M); +end diff --git a/sourcecodes/bnt-master/KPMtools/mysubset.m b/sourcecodes/bnt-master/KPMtools/mysubset.m new file mode 100644 index 00000000..a3a2ccd2 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mysubset.m @@ -0,0 +1,11 @@ +function p=mysubset(small,large) +% MYSUBSET Is the small set of +ve integers a subset of the large set? +% p = mysubset(small, large) + +% Surprisingly, this is not built-in. + +if isempty(small) + p = 1; % isempty(large); +else + p = length(myintersect(small,large)) == length(small); +end diff --git a/sourcecodes/bnt-master/KPMtools/mysymsetdiff.m b/sourcecodes/bnt-master/KPMtools/mysymsetdiff.m new file mode 100644 index 00000000..4f143610 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/mysymsetdiff.m @@ -0,0 +1,29 @@ +function C = mysymsetdiff(A,B) +% MYSYMSETDIFF Symmetric set difference of two sets of positive integers (much faster than built-in setdiff) +% C = mysetdiff(A,B) +% C = (A\B) union (B\A) = { things that A and B don't have in common } + +if isempty(A) + ma = 0; +else + ma = max(A); +end + +if isempty(B) + mb = 0; +else + mb = max(B); +end + +if ma==0 + C = B; +elseif mb==0 + C = A; +else % both non-empty + m = max(ma,mb); + bitsA = sparse(1, m); + bitsA(A) = 1; + bitsB = sparse(1, m); + bitsB(B) = 1; + C = find(xor(bitsA, bitsB)); +end diff --git a/sourcecodes/bnt-master/KPMtools/myunion.m b/sourcecodes/bnt-master/KPMtools/myunion.m new file mode 100644 index 00000000..0f358020 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/myunion.m @@ -0,0 +1,29 @@ +function C = myunion(A,B) +% MYUNION Union of two sets of positive integers (much faster than built-in union) +% C = myunion(A,B) + +if isempty(A) + ma = 0; +else + ma = max(A); +end + +if isempty(B) + mb = 0; +else + mb = max(B); +end + +if ma==0 && mb==0 + C = []; +elseif ma==0 && mb>0 + C = B; +elseif ma>0 && mb==0 + C = A; +else + %bits = sparse(1, max(ma,mb)); + bits = zeros(1, max(ma,mb)); + bits(A) = 1; + bits(B) = 1; + C = find(bits); +end diff --git a/sourcecodes/bnt-master/KPMtools/nchoose2.m b/sourcecodes/bnt-master/KPMtools/nchoose2.m new file mode 100644 index 00000000..1827d053 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/nchoose2.m @@ -0,0 +1,35 @@ +function c = nchoose2(v, f) +%NCHOOSE2 All combinations of N elements taken two at a time. +% +% NCHOOSE2(1:N) or NCHOOSEK(V) where V is a vector of length N, +% produces a matrix with N*(N-1)/2 rows and K columns. Each row of +% the result has K of the elements in the vector V. +% +% NCHOOSE2(N,FLAG) is the same as NCHOOSE2(1:N) but faster. +% +% NCHOOSE2(V) is much faster than NCHOOSEK(V,2). +% +% See also NCHOOSEK, PERMS. + +% Author: Peter J. Acklam +% Time-stamp: 2000-03-03 13:03:59 +% E-mail: jacklam@math.uio.no +% URL: http://www.math.uio.no/~jacklam + + nargs = nargin; + if nargs < 1 + error('Not enough input arguments.'); + elseif nargs == 1 + v = v(:); + n = length(v); + elseif nargs == 2 + n = v; + else + error('Too many input arguments.'); + end + + [ c(:,2), c(:,1) ] = find( tril( ones(n), -1 ) ); + + if nargs == 1 + c = v(c); + end diff --git a/sourcecodes/bnt-master/KPMtools/ncols.m b/sourcecodes/bnt-master/KPMtools/ncols.m new file mode 100644 index 00000000..a6fe1352 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/ncols.m @@ -0,0 +1,4 @@ +function c = cols(x) +% COLS The number of columns. +% COLS is a more readable alternative to size(x,2). +c = size(x,2); diff --git a/sourcecodes/bnt-master/KPMtools/nonmaxsup.m b/sourcecodes/bnt-master/KPMtools/nonmaxsup.m new file mode 100644 index 00000000..f94d4560 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/nonmaxsup.m @@ -0,0 +1,42 @@ +% NONMAXSUP - Non-maximal Suppression +% +% Usage: cim = nonmaxsup(im, radius) +% +% Arguments: +% im - image to be processed. +% radius - radius of region considered in non-maximal +% suppression (optional). Typical values to use might +% be 1-3. Default is 1. +% +% Returns: +% cim - image with pixels that are not maximal within a +% square neighborhood zeroed out. + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +function cim = nonmaxsup(m, radius) + if (nargin == 1) radius = 1; end + % Extract local maxima by performing a grey scale morphological + % dilation and then finding points in the corner strength image that + % match the dilated image and are also greater than the threshold. + sze = 2 * radius + 1; % Size of mask. + mx = ordfilt2(m, sze^2, ones(sze)); % Grey-scale dilate. + cim = sparse(m .* (m == mx)); + + diff --git a/sourcecodes/bnt-master/KPMtools/normalise.m b/sourcecodes/bnt-master/KPMtools/normalise.m new file mode 100644 index 00000000..c6585921 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/normalise.m @@ -0,0 +1,34 @@ +function [M, z] = normalise(A, dim) +% NORMALISE Make the entries of a (multidimensional) array sum to 1 +% [M, c] = normalise(A) +% c is the normalizing constant +% +% [M, c] = normalise(A, dim) +% If dim is specified, we normalise the specified dimension only, +% otherwise we normalise the whole array. + +if nargin < 2 + z = sum(A(:)); + % Set any zeros to one before dividing + % This is valid, since c=0 => all i. A(i)=0 => the answer should be 0/1=0 + s = z + (z==0); + M = A / s; +elseif dim==1 % normalize each column + z = sum(A); + s = z + (z==0); + %M = A ./ (d'*ones(1,size(A,1)))'; + M = A ./ repmatC(s, size(A,1), 1); +else + % Keith Battocchi - v. slow because of repmat + z=sum(A,dim); + s = z + (z==0); + L=size(A,dim); + d=length(size(A)); + v=ones(d,1); + v(dim)=L; + %c=repmat(s,v); + c=repmat(s,v'); + M=A./c; +end + + diff --git a/sourcecodes/bnt-master/KPMtools/normaliseC.c b/sourcecodes/bnt-master/KPMtools/normaliseC.c new file mode 100644 index 00000000..b0878f28 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/normaliseC.c @@ -0,0 +1,29 @@ +/* C mex version of normalise.m in misc directory */ + +#include "mex.h" + +void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]) +{ + double *T, *sum_ptr, sum; + int i, N; + + plhs[0] = mxDuplicateArray(prhs[0]); + T = mxGetPr(plhs[0]); + if(mxIsSparse(plhs[0])) N = mxGetJc(plhs[0])[mxGetN(plhs[0])]; + else N = mxGetNumberOfElements(plhs[0]); + + plhs[1] = mxCreateDoubleMatrix(1, 1, mxREAL); + sum_ptr = mxGetPr(plhs[1]); + + sum = 0; + for (i = 0; i < N; i++) { + sum += *T++; + } + T = mxGetPr(plhs[0]); + if (sum > 0) { + for (i = 0; i < N; i++) { + *T++ /= sum; + } + } + *sum_ptr = sum; +} diff --git a/sourcecodes/bnt-master/KPMtools/normaliseC.dll b/sourcecodes/bnt-master/KPMtools/normaliseC.dll new file mode 100644 index 00000000..dead3669 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/normaliseC.dll Binary files differdiff --git a/sourcecodes/bnt-master/KPMtools/normalize.m b/sourcecodes/bnt-master/KPMtools/normalize.m new file mode 100644 index 00000000..c6585921 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/normalize.m @@ -0,0 +1,34 @@ +function [M, z] = normalise(A, dim) +% NORMALISE Make the entries of a (multidimensional) array sum to 1 +% [M, c] = normalise(A) +% c is the normalizing constant +% +% [M, c] = normalise(A, dim) +% If dim is specified, we normalise the specified dimension only, +% otherwise we normalise the whole array. + +if nargin < 2 + z = sum(A(:)); + % Set any zeros to one before dividing + % This is valid, since c=0 => all i. A(i)=0 => the answer should be 0/1=0 + s = z + (z==0); + M = A / s; +elseif dim==1 % normalize each column + z = sum(A); + s = z + (z==0); + %M = A ./ (d'*ones(1,size(A,1)))'; + M = A ./ repmatC(s, size(A,1), 1); +else + % Keith Battocchi - v. slow because of repmat + z=sum(A,dim); + s = z + (z==0); + L=size(A,dim); + d=length(size(A)); + v=ones(d,1); + v(dim)=L; + %c=repmat(s,v); + c=repmat(s,v'); + M=A./c; +end + + diff --git a/sourcecodes/bnt-master/KPMtools/nrows.m b/sourcecodes/bnt-master/KPMtools/nrows.m new file mode 100644 index 00000000..a8046995 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/nrows.m @@ -0,0 +1,4 @@ +function r = rows(x) +% ROWS The number of rows. +% ROWS is a more readable alternative to size(x,1). +r = size(x,1); diff --git a/sourcecodes/bnt-master/KPMtools/num2strcell.m b/sourcecodes/bnt-master/KPMtools/num2strcell.m new file mode 100644 index 00000000..a63f86d4 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/num2strcell.m @@ -0,0 +1,16 @@ +function c = num2strcell(n, format) +% num2strcell Convert vector of numbers to cell array of strings +% function c = num2strcell(n, format) +% +% If format is omitted, we use +% c{i} = sprintf('%d', n(i)) + +if nargin < 2, format = '%d'; end + +N = length(n); +c = cell(1,N); +for i=1:N + c{i} = sprintf(format, n(i)); +end + + diff --git a/sourcecodes/bnt-master/KPMtools/optimalMatching.m b/sourcecodes/bnt-master/KPMtools/optimalMatching.m new file mode 100644 index 00000000..a794ba02 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/optimalMatching.m @@ -0,0 +1,90 @@ +% MATCH - Solves the weighted bipartite matching (or assignment) +% problem. +% +% Usage: a = match(C); +% +% Arguments: +% C - an m x n cost matrix; the sets are taken to be +% 1:m and 1:n; C(i, j) gives the cost of matching +% items i (of the first set) and j (of the second set) +% +% Returns: +% +% a - an m x 1 assignment vector, which gives the +% minimum cost assignment. a(i) is the index of +% the item of 1:n that was matched to item i of +% 1:m. If item i (of 1:m) was not matched to any +% item of 1:n, then a(i) is zero. + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +function [a] = optimalMatching(C) + +% Trivial cases: +[p, q] = size(C); +if (p == 0) + a = []; + return; +elseif (q == 0) + a = zeros(p, 1); + return; +end + + +if 0 +% First, reduce the problem by making easy optimal matches. If two +% elements agree that they are the best match, then match them up. +[x, a] = min(C, [], 2); +[y, b] = min(C, [], 1); +u = find(1:p ~= b(a(:))); +a(u) = 0; +v = find(1:q ~= a(b(:))'); +C = C(u, v); +if (isempty(C)) return; end +end + +% Get the (new) size of the two sets, u and v. +[m, n] = size(C); + +%mx = realmax; +mx = 2*max(C(:)); +mn = -2*min(C(:)); +% Pad the affinity matrix to be square +if (m < n) + C = [C; mx * ones(n - m, n)]; +elseif (n < m) + C = [C, mx * ones(m, m - n)]; +end + +% Run the Hungarian method. First replace infinite values by the +% largest (or smallest) finite values. +C(find(isinf(C) & (C > 0))) = mx; +C(find(isinf(C) & (C < 0))) = mn; +%fprintf('running hungarian\n'); +[b, cost] = hungarian(C'); + +% Extract only the real assignments +ap = b(1:m)'; +ap(find(ap > n)) = 0; + +a = ap; +%% Incorporate this sub-assignment into the complete assignment +% k = find(ap); +% a(u(k)) = v(ap(k)); + diff --git a/sourcecodes/bnt-master/KPMtools/optimalMatchingTest.m b/sourcecodes/bnt-master/KPMtools/optimalMatchingTest.m new file mode 100644 index 00000000..5cb2ce4b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/optimalMatchingTest.m @@ -0,0 +1,18 @@ +% Consider matching sources to detections + +% s1 d2 +% s2 d3 +% d1 + +a = optimalMatching([52;0.01]) + +% sources(:,i) = [x y] coords +sources = [0.1 0.7; 0.6 0.4]'; +detections = [0.2 0.2; 0.2 0.8; 0.7 0.1]'; +dst = sqdist(sources, detections) + +% a = [2 3] which means s1-d2, s2-d3 +a = optimalMatching(dst) + +% a = [0 1 2] which means d1-0, d2-s1, d3-s2 +a = optimalMatching(dst') diff --git a/sourcecodes/bnt-master/KPMtools/partitionData.m b/sourcecodes/bnt-master/KPMtools/partitionData.m new file mode 100644 index 00000000..3e5eb5fa --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/partitionData.m @@ -0,0 +1,25 @@ +function varargout = partitionData(Ndata, varargin) +% PARTITIONDATA Partition a vector of indices into random sets +% [a,b,c,...] = partitionData(N, 0.3, 0.2, 0.5, ...) +% +% Examples: +% [a,b,c]=partitionData(105,0.3,0.2,0.5); +% a= 1:30, b=32:52, c=52:105 (last bin gets all the left over) + +Npartitions = length(varargin); +perm = randperm(Ndata); +%perm = 1:Ndata; +ndx = 1; +for i=1:Npartitions + pc(i) = varargin{i}; + Nbin(i) = fix(Ndata*pc(i)); + low(i) = ndx; + if i==Npartitions + high(i) = Ndata; + else + high(i) = low(i)+Nbin(i)-1; + end + varargout{i} = perm(low(i):high(i)); + ndx = ndx+Nbin(i); +end + diff --git a/sourcecodes/bnt-master/KPMtools/partition_matrix_vec.m b/sourcecodes/bnt-master/KPMtools/partition_matrix_vec.m new file mode 100644 index 00000000..6ac456c5 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/partition_matrix_vec.m @@ -0,0 +1,21 @@ +function [m1, m2, K11, K12, K21, K22] = partition_matrix_vec(m, K, n1, n2, bs) +% PARTITION_MATRIX_VEC Partition a vector and matrix into blocks. +% [m1, m2, K11, K12, K21, K22] = partition_matrix_vec(m, K, blocks1, blocks2, bs) +% +% bs(i) = block size of i'th node +% +% Example: +% n1 = [6 8], n2 = [5], bs = [- - - - 2 1 - 2], where - = don't care +% m = [0.1 0.2 0.3 0.4 0.5], K = some 5*5 matrix, +% So E[X5] = [0.1 0.2], E[X6] = [0.3], E[X8] = [0.4 0.5] +% m1 = [0.3 0.4 0.5], m2 = [0.1 0.2]; + +dom = myunion(n1, n2); +n1i = block(find_equiv_posns(n1, dom), bs(dom)); +n2i = block(find_equiv_posns(n2, dom), bs(dom)); +m1 = m(n1i); +m2 = m(n2i); +K11 = K(n1i, n1i); +K12 = K(n1i, n2i); +K21 = K(n2i, n1i); +K22 = K(n2i, n2i); diff --git a/sourcecodes/bnt-master/KPMtools/pca_kpm.m b/sourcecodes/bnt-master/KPMtools/pca_kpm.m new file mode 100644 index 00000000..d6cbd366 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/pca_kpm.m @@ -0,0 +1,32 @@ +function [pc_vec]=pca_kpm(features,N, method); +% PCA_KPM Compute top N principal components using eigs or svd. +% [pc_vec]=pca_kpm(features,N) +% +% features(:,i) is the i'th example - each COLUMN is an observation +% pc_vec(:,j) is the j'th basis function onto which you should project the data +% using pc_vec' * features + +[d ncases] = size(features); +fm=features-repmat(mean(features,2), 1, ncases); + + +if method==1 % d*d < d*ncases + fprintf('pca_kpm eigs\n'); + options.disp = 0; + C = cov(fm'); % d x d matrix + [pc_vec, evals] = eigs(C, N, 'LM', options); +else + % [U,D,V] = SVD(fm), U(:,i)=evec of fm fm', V(:,i) = evec of fm' fm + fprintf('pca_kpm svds\n'); + [U,D,V] = svds(fm', N); + pc_vec = V; +end + +if 0 +X = randn(5,3); +X = X-repmat(mean(X),5,1); +C = X'*X; +C2=cov(X) +[U,D,V]=svd(X); +[V2,D2]=eig(X) +end diff --git a/sourcecodes/bnt-master/KPMtools/pca_netlab.m b/sourcecodes/bnt-master/KPMtools/pca_netlab.m new file mode 100644 index 00000000..4b7063d6 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/pca_netlab.m @@ -0,0 +1,42 @@ +function [PCcoeff, PCvec] = pca(data, N) +%PCA Principal Components Analysis +% +% Description +% PCCOEFF = PCA(DATA) computes the eigenvalues of the covariance +% matrix of the dataset DATA and returns them as PCCOEFF. These +% coefficients give the variance of DATA along the corresponding +% principal components. +% +% PCCOEFF = PCA(DATA, N) returns the largest N eigenvalues. +% +% [PCCOEFF, PCVEC] = PCA(DATA) returns the principal components as well +% as the coefficients. This is considerably more computationally +% demanding than just computing the eigenvalues. +% +% See also +% EIGDEC, GTMINIT, PPCA +% + +% Copyright (c) Ian T Nabney (1996-2001) + +if nargin == 1 + N = size(data, 2); +end + +if nargout == 1 + evals_only = logical(1); +else + evals_only = logical(0); +end + +if N ~= round(N) | N < 1 | N > size(data, 2) + error('Number of PCs must be integer, >0, < dim'); +end + +% Find the sorted eigenvalues of the data covariance matrix +if evals_only + PCcoeff = eigdec(cov(data), N); +else + [PCcoeff, PCvec] = eigdec(cov(data), N); +end + diff --git a/sourcecodes/bnt-master/KPMtools/pick.m b/sourcecodes/bnt-master/KPMtools/pick.m new file mode 100644 index 00000000..8e40d937 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/pick.m @@ -0,0 +1,9 @@ +function [i,j] = pick(ndx) +% PICK Pick an entry at random from a vector +% function [i,j] = pick(ndx) +% +% i = ndx(j) for j ~ U(1:length(ndx)) + +dist = normalize(ones(1,length(ndx))); +j = sample_discrete(dist); +i = ndx(j); diff --git a/sourcecodes/bnt-master/KPMtools/plotBox.m b/sourcecodes/bnt-master/KPMtools/plotBox.m new file mode 100644 index 00000000..fb057c33 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotBox.m @@ -0,0 +1,22 @@ +function [h, ht] =plotBox(box, col, str) +% function h=plotBox(box, col, str) +% +% box = [xlow xhigh ylow yhigh] +% col = color (default - red) +% str = string printed at center (default '') + +if nargin < 2, col = 'r'; end +if nargin < 3, str = ''; end + +box = double(box); % fails on single + +h = plot([box(1) box(2) box(2) box(1) box(1)], [ box(3) box(3) box(4) box(4) box(3)]); +set(h, 'color', col); +set(h, 'linewidth', 2); +if ~isempty(str) + xc = mean(box(1:2)); + yc = mean(box(3:4)); + ht = text(xc, yc, str); +else + ht = []; +end diff --git a/sourcecodes/bnt-master/KPMtools/plotColors.m b/sourcecodes/bnt-master/KPMtools/plotColors.m new file mode 100644 index 00000000..ded97483 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotColors.m @@ -0,0 +1,10 @@ +function styles = plotColors() + +colors = ['r' 'b' 'k' 'g' 'c' 'y' 'm' ... + 'r' 'b' 'k' 'g' 'c' 'y' 'm']; +symbols = ['o' 'x' '+' '>' '<' '^' 'v' ... + '*' 'p' 'h' 's' 'd' 'o' 'x']; +for i=1:length(colors) + styles{i} = sprintf('-%s%s', colors(i), symbols(i)); +end + diff --git a/sourcecodes/bnt-master/KPMtools/plotROC.m b/sourcecodes/bnt-master/KPMtools/plotROC.m new file mode 100644 index 00000000..4c3de06e --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotROC.m @@ -0,0 +1,26 @@ +function [falseAlarmRate, detectionRate, area, th] = plotROC(confidence, testClass, col, varargin) +% function [falseAlarmRate, detectionRate, area, th] = plotroc(confidence, testClass, color) + +if nargin < 3, col = []; end + +[scale01] = process_options(varargin, 'scale01', 1); + +[falseAlarmRate detectionRate area th] = computeROC(confidence, testClass); + +if ~isempty(col) + h=plot(falseAlarmRate, detectionRate, [col '-']); + %set(h, 'linewidth', 2); + ex = 0.05*max(falseAlarmRate); + ey = 0.05; + if scale01 + axis([0-ex max(falseAlarmRate)+ex 0-ey 1+ey]) + else + % zoom in on the top left corner + axis([0-ex max(falseAlarmRate)*0.5+ex 0.5-ey 1+ey]) + end + grid on + ylabel('detection rate') + %xlabel('# false alarms') + xlabel('false alarm rate') +end + diff --git a/sourcecodes/bnt-master/KPMtools/plotROCkpm.m b/sourcecodes/bnt-master/KPMtools/plotROCkpm.m new file mode 100644 index 00000000..a77fd568 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotROCkpm.m @@ -0,0 +1,69 @@ +function [falseAlarmRate, detectionRate, area, th] = plotROC(confidence, testClass, col, varargin) +% You pass the scores and the classes, and the function returns the false +% alarm rate and the detection rate for different points across the ROC. +% +% [faR, dR] = plotROC(score, class) +% +% faR (false alarm rate) is uniformly sampled from 0 to 1 +% dR (detection rate) is computed using the scores. +% +% class = 0 => target absent +% class = 1 => target present +% +% score is the output of the detector, or any other measure of detection. +% There is no plot unless you add a third parameter that is the color of +% the graph. For instance: +% [faR, dR] = plotROC(score, class, 'r') +% +% faR, dR are size 1x1250 + +if nargin < 3, col = []; end +[scale01] = process_options(varargin, 'scale01', 1); + +S = rand('state'); +rand('state',0); +confidence = confidence + rand(size(confidence))*10^(-10); +rand('state',S) + +ndxAbs = find(testClass==0); % absent +ndxPres = find(testClass==1); % present + +[th, j] = sort(confidence(ndxAbs)); +th = th(fix(linspace(1, length(th), 1250))); + +cAbs = confidence(ndxAbs); +cPres = confidence(ndxPres); +for t=1:length(th) + if length(ndxPres) == 0 + detectionRate(t) = 0; + else + detectionRate(t) = sum(cPres>=th(t)) / length(ndxPres); + end + if length(ndxAbs) == 0 + falseAlarmRate(t) = 0; + else + falseAlarmRate(t) = sum(cAbs>=th(t)) / length(ndxAbs); + end + + %detectionRate(t) = sum(confidence(ndxPres)>=th(t)) / length(ndxPres); + %falseAlarmRate(t) = sum(confidence(ndxAbs)>=th(t)) / length(ndxAbs); + %detections(t) = sum(confidence(ndxPres)>=th(t)); + %falseAlarms(t) = sum(confidence(ndxAbs)>=th(t)); +end + +area = sum(abs(falseAlarmRate(2:end) - falseAlarmRate(1:end-1)) .* detectionRate(2:end)); + +if ~isempty(col) + h=plot(falseAlarmRate, detectionRate, [col '-']); + %set(h, 'linewidth', 2); + e = 0.05; + if scale01 + axis([0-e 1+e 0-e 1+e]) + else + % zoom in on the top left corner + axis([0-e 0.5+e 0.5-e 1+e]) + end + grid on + ylabel('detection rate') + xlabel('false alarm rate') +end diff --git a/sourcecodes/bnt-master/KPMtools/plot_axis_thru_origin.m b/sourcecodes/bnt-master/KPMtools/plot_axis_thru_origin.m new file mode 100644 index 00000000..353376e4 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plot_axis_thru_origin.m @@ -0,0 +1,3 @@ +function plot_axis_thru_origin() + +lnx=line(get(gca,'xlim'),[0 0]); lny=line([0 0],get(gca,'ylim')); diff --git a/sourcecodes/bnt-master/KPMtools/plot_ellipse.m b/sourcecodes/bnt-master/KPMtools/plot_ellipse.m new file mode 100644 index 00000000..e101a158 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plot_ellipse.m @@ -0,0 +1,19 @@ +% PLOT_ELLIPSE +% h=plot_ellipse(x,y,theta,a,b) +% +% This routine plots an ellipse with centre (x,y), axis lengths a,b +% with major axis at an angle of theta radians from the horizontal. + +% +% Author: P. Fieguth +% Jan. 98 +% +%http://ocho.uwaterloo.ca/~pfieguth/Teaching/372/plot_ellipse.m + +function h=plot_ellipse(x,y,theta,a,b) + +np = 100; +ang = [0:np]*2*pi/np; +R = [cos(theta) -sin(theta); sin(theta) cos(theta)]; +pts = [x;y]*ones(size(ang)) + R*[cos(ang)*a; sin(ang)*b]; +h=plot( pts(1,:), pts(2,:) ); diff --git a/sourcecodes/bnt-master/KPMtools/plot_matrix.m b/sourcecodes/bnt-master/KPMtools/plot_matrix.m new file mode 100644 index 00000000..58a9a964 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plot_matrix.m @@ -0,0 +1,48 @@ +function plot_matrix(G, bw) +% PLOT_MATRIX Plot a 2D matrix as a grayscale image, and label the axes +% +% plot_matrix(M) +% +% For 0/1 matrices (eg. adjacency matrices), use +% plot_matrix(M,1) + +if nargin < 2, bw = 0; end + +if 0 + imagesc(G) + %image(G) + %colormap([1 1 1; 0 0 0]); % black squares on white background + %colormap(gray) + grid on + n = length(G); + + % shift the grid lines so they don't intersect the squares + set(gca,'xtick',1.5:1:n); + set(gca,'ytick',1.5:1:n); + + % Turn off the confusing labels, which are fractional + % Ideally we could shift the labels to lie between the axis lines... +% set(gca,'xticklabel', []); +% set(gca,'yticklabel', []); +else + % solution provided by Jordan Rosenthal <jr@ece.gatech.edu> + % You can plot the grid lines manually: + % This uses the trick that a point with a value nan does not get plotted. + imagesc(G); + if bw + colormap([1 1 1; 0 0 0]); + end + n = length(G); + x = 1.5:1:n; + x = [ x; x; repmat(nan,1,n-1) ]; + y = [ 0.5 n+0.5 nan ].'; + y = repmat(y,1,n-1); + x = x(:); + y = y(:); + line(x,y,'linestyle',':','color','k'); + line(y,x,'linestyle',':','color','k'); + set(gca,'xtick',1:n) + set(gca,'ytick',1:n) +end + + diff --git a/sourcecodes/bnt-master/KPMtools/plot_polygon.m b/sourcecodes/bnt-master/KPMtools/plot_polygon.m new file mode 100644 index 00000000..d5aa1e19 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plot_polygon.m @@ -0,0 +1,23 @@ +function out=plot_polygon(p, args, close_loop) +% PLOT_POLYGON +% function handle=plot_polygon(p, args, close_loop) +% p(1,i), p(2,i) are the x/y coords of point i. +% If non-empty, args are passed thru to the plot command. +% If close_loop = 1, connect the last point to the first + +% All rights reserved. Documentation updated April 1999. +% Matt Kawski. http://math.la.asu.edu/~kawski +% He calls it pplot + +if nargin < 2, args = []; end +if nargin < 3, close_loop = 0; end + +if close_loop + p = [p p(:,1)]; +end + +if isempty(args) + out=plot(p(1,:),p(2,:)); +else + out=plot(p(1,:),p(2,:),args); +end diff --git a/sourcecodes/bnt-master/KPMtools/plotcov2.m b/sourcecodes/bnt-master/KPMtools/plotcov2.m new file mode 100644 index 00000000..b42c8c1b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotcov2.m @@ -0,0 +1,86 @@ +% PLOTCOV2 - Plots a covariance ellipse with major and minor axes +% for a bivariate Gaussian distribution. +% +% Usage: +% h = plotcov2(mu, Sigma[, OPTIONS]); +% +% Inputs: +% mu - a 2 x 1 vector giving the mean of the distribution. +% Sigma - a 2 x 2 symmetric positive semi-definite matrix giving +% the covariance of the distribution (or the zero matrix). +% +% Options: +% 'conf' - a scalar between 0 and 1 giving the confidence +% interval (i.e., the fraction of probability mass to +% be enclosed by the ellipse); default is 0.9. +% 'num-pts' - the number of points to be used to plot the +% ellipse; default is 100. +% +% This function also accepts options for PLOT. +% +% Outputs: +% h - a vector of figure handles to the ellipse boundary and +% its major and minor axes +% +% See also: PLOTCOV3 + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +function h = plotcov2(mu, Sigma, varargin) + +if size(Sigma) ~= [2 2], error('Sigma must be a 2 by 2 matrix'); end +if length(mu) ~= 2, error('mu must be a 2 by 1 vector'); end + +[p, ... + n, ... + plot_opts] = process_options(varargin, 'conf', 0.9, ... + 'num-pts', 100); +h = []; +holding = ishold; +if (Sigma == zeros(2, 2)) + z = mu; +else + % Compute the Mahalanobis radius of the ellipsoid that encloses + % the desired probability mass. + k = conf2mahal(p, 2); + % The major and minor axes of the covariance ellipse are given by + % the eigenvectors of the covariance matrix. Their lengths (for + % the ellipse with unit Mahalanobis radius) are given by the + % square roots of the corresponding eigenvalues. + if (issparse(Sigma)) + [V, D] = eigs(Sigma); + else + [V, D] = eig(Sigma); + end + % Compute the points on the surface of the ellipse. + t = linspace(0, 2*pi, n); + u = [cos(t); sin(t)]; + w = (k * V * sqrt(D)) * u; + z = repmat(mu, [1 n]) + w; + % Plot the major and minor axes. + L = k * sqrt(diag(D)); + h = plot([mu(1); mu(1) + L(1) * V(1, 1)], ... + [mu(2); mu(2) + L(1) * V(2, 1)], plot_opts{:}); + hold on; + h = [h; plot([mu(1); mu(1) + L(2) * V(1, 2)], ... + [mu(2); mu(2) + L(2) * V(2, 2)], plot_opts{:})]; +end + +h = [h; plot(z(1, :), z(2, :), plot_opts{:})]; +if (~holding) hold off; end diff --git a/sourcecodes/bnt-master/KPMtools/plotcov2New.m b/sourcecodes/bnt-master/KPMtools/plotcov2New.m new file mode 100644 index 00000000..ec5554bb --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotcov2New.m @@ -0,0 +1,119 @@ +% PLOTCOV2 - Plots a covariance ellipsoid with axes for a bivariate +% Gaussian distribution. +% +% Usage: +% [h, s] = plotcov2(mu, Sigma[, OPTIONS]); +% +% Inputs: +% mu - a 2 x 1 vector giving the mean of the distribution. +% Sigma - a 2 x 2 symmetric positive semi-definite matrix giving +% the covariance of the distribution (or the zero matrix). +% +% Options: +% 'conf' - a scalar between 0 and 1 giving the confidence +% interval (i.e., the fraction of probability mass to +% be enclosed by the ellipse); default is 0.9. +% 'num-pts' - if the value supplied is n, then (n + 1)^2 points +% to be used to plot the ellipse; default is 20. +% 'label' - if non-empty, a string that will label the +% ellipsoid (default: []) +% 'plot-axes' - a 0/1 flag indicating if the ellipsoid's axes +% should be plotted (default: 1) +% 'plot-opts' - a cell vector of arguments to be handed to PLOT3 +% to contol the appearance of the axes, e.g., +% {'Color', 'g', 'LineWidth', 1}; the default is {} +% 'fill-color' - a color specifier; is this is not [], the +% covariance ellipse is filled with this color +% (default: []) +% +% Outputs: +% h - a vector of handles on the axis lines +% +% See also: PLOTCOV3 + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +function [h, s] = plotcov2New(mu, Sigma, varargin) + +h = []; +s = []; + +if size(Sigma) ~= [2 2], error('Sigma must be a 2 by 2 matrix'); end +if length(mu) ~= 2, error('mu must be a 2 by 1 vector'); end + +Sigma = checkpsd(Sigma); + +[p, ... + n, ... + label, ... + plot_axes, ... + plot_opts, ... + fill_color] = process_options(varargin, 'conf', 0.9, ... + 'num-pts', 20, ... + 'label', [], ... + 'plot-axes', 1, ... + 'plot-opts', {}, ... + 'fill-color', []); +holding = ishold; +% Compute the Mahalanobis radius of the ellipsoid that encloses +% the desired probability mass. +k = conf2mahal(p, 2); +% Scale the covariance matrix so the confidence region has unit +% Mahalanobis distance. +Sigma = Sigma * k; +% The axes of the covariance ellipse are given by the eigenvectors of +% the covariance matrix. Their lengths (for the ellipse with unit +% Mahalanobis radius) are given by the square roots of the +% corresponding eigenvalues. +[V, D] = eig(full(Sigma)); +V = real(V); +D = real(D); +D = abs(D); + +% Compute the points on the boundary of the ellipsoid. +t = linspace(0, 2*pi, n); +u = [cos(t(:))'; sin(t(:))']; +w = (V * sqrt(D)) * u; +z = repmat(mu(:), [1 n]) + w; +h = [h; plot(z(1, :), z(2, :), plot_opts{:})]; +if (~isempty(fill_color)) + s = patch(z(1, :), z(2, :), fill_color); +end + +% Plot the axes. +if (plot_axes) + hold on; + L = sqrt(diag(D)); + h = plot([mu(1); mu(1) + L(1) * V(1, 1)], ... + [mu(2); mu(2) + L(1) * V(2, 1)], plot_opts{:}); + h = [h; plot([mu(1); mu(1) + L(2) * V(1, 2)], ... + [mu(2); mu(2) + L(2) * V(2, 2)], plot_opts{:})]; +end + + +if (~isempty(label)) + th = text(mu(1), mu(2), label); + set(th, 'FontSize', 18); + set(th, 'FontName', 'Times'); + set(th, 'FontWeight', 'bold'); + set(th, 'FontAngle', 'italic'); + set(th, 'HorizontalAlignment', 'center'); +end + +if (~holding & plot_axes) hold off; end diff --git a/sourcecodes/bnt-master/KPMtools/plotcov3.m b/sourcecodes/bnt-master/KPMtools/plotcov3.m new file mode 100644 index 00000000..bacdcb27 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotcov3.m @@ -0,0 +1,109 @@ +% PLOTCOV3 - Plots a covariance ellipsoid with axes for a trivariate +% Gaussian distribution. +% +% Usage: +% [h, s] = plotcov3(mu, Sigma[, OPTIONS]); +% +% Inputs: +% mu - a 3 x 1 vector giving the mean of the distribution. +% Sigma - a 3 x 3 symmetric positive semi-definite matrix giving +% the covariance of the distribution (or the zero matrix). +% +% Options: +% 'conf' - a scalar between 0 and 1 giving the confidence +% interval (i.e., the fraction of probability mass to +% be enclosed by the ellipse); default is 0.9. +% 'num-pts' - if the value supplied is n, then (n + 1)^2 points +% to be used to plot the ellipse; default is 20. +% 'plot-opts' - a cell vector of arguments to be handed to PLOT3 +% to contol the appearance of the axes, e.g., +% {'Color', 'g', 'LineWidth', 1}; the default is {} +% 'surf-opts' - a cell vector of arguments to be handed to SURF +% to contol the appearance of the ellipsoid +% surface; a nice possibility that yields +% transparency is: {'EdgeAlpha', 0, 'FaceAlpha', +% 0.1, 'FaceColor', 'g'}; the default is {} +% +% Outputs: +% h - a vector of handles on the axis lines +% s - a handle on the ellipsoid surface object +% +% See also: PLOTCOV2 + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +function [h, s] = plotcov3(mu, Sigma, varargin) + +if size(Sigma) ~= [3 3], error('Sigma must be a 3 by 3 matrix'); end +if length(mu) ~= 3, error('mu must be a 3 by 1 vector'); end + +[p, ... + n, ... + plot_opts, ... + surf_opts] = process_options(varargin, 'conf', 0.9, ... + 'num-pts', 20, ... + 'plot-opts', {}, ... + 'surf-opts', {}); +h = []; +holding = ishold; +if (Sigma == zeros(3, 3)) + z = mu; +else + % Compute the Mahalanobis radius of the ellipsoid that encloses + % the desired probability mass. + k = conf2mahal(p, 3); + % The axes of the covariance ellipse are given by the eigenvectors of + % the covariance matrix. Their lengths (for the ellipse with unit + % Mahalanobis radius) are given by the square roots of the + % corresponding eigenvalues. + if (issparse(Sigma)) + [V, D] = eigs(Sigma); + else + [V, D] = eig(Sigma); + end + if (any(diag(D) < 0)) + error('Invalid covariance matrix: not positive semi-definite.'); + end + % Compute the points on the surface of the ellipsoid. + t = linspace(0, 2*pi, n); + [X, Y, Z] = sphere(n); + u = [X(:)'; Y(:)'; Z(:)']; + w = (k * V * sqrt(D)) * u; + z = repmat(mu(:), [1 (n + 1)^2]) + w; + + % Plot the axes. + L = k * sqrt(diag(D)); + h = plot3([mu(1); mu(1) + L(1) * V(1, 1)], ... + [mu(2); mu(2) + L(1) * V(2, 1)], ... + [mu(3); mu(3) + L(1) * V(3, 1)], plot_opts{:}); + hold on; + h = [h; plot3([mu(1); mu(1) + L(2) * V(1, 2)], ... + [mu(2); mu(2) + L(2) * V(2, 2)], ... + [mu(3); mu(3) + L(2) * V(3, 2)], plot_opts{:})]; + h = [h; plot3([mu(1); mu(1) + L(3) * V(1, 3)], ... + [mu(2); mu(2) + L(3) * V(2, 3)], ... + [mu(3); mu(3) + L(3) * V(3, 3)], plot_opts{:})]; +end + +s = surf(reshape(z(1, :), [(n + 1) (n + 1)]), ... + reshape(z(2, :), [(n + 1) (n + 1)]), ... + reshape(z(3, :), [(n + 1) (n + 1)]), ... + surf_opts{:}); + +if (~holding) hold off; end diff --git a/sourcecodes/bnt-master/KPMtools/plotgauss1d.m b/sourcecodes/bnt-master/KPMtools/plotgauss1d.m new file mode 100644 index 00000000..b20da3c1 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotgauss1d.m @@ -0,0 +1,9 @@ +function h = plotgauss1d(mu, sigma2) +% function h = plotgauss1d(mu, sigma^2) +% Example +% plotgauss1d(0,5); hold on; h=plotgauss1d(0,2);set(h,'color','r') + +sigma = sqrt(sigma2); +x = linspace(mu-3*sigma, mu+3*sigma, 100); +p = gaussian_prob(x, mu, sigma2); +h = plot(x, p, '-'); diff --git a/sourcecodes/bnt-master/KPMtools/plotgauss2d.m b/sourcecodes/bnt-master/KPMtools/plotgauss2d.m new file mode 100644 index 00000000..a507b258 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotgauss2d.m @@ -0,0 +1,130 @@ +function h=plotgauss2d(mu, Sigma) +% PLOTGAUSS2D Plot a 2D Gaussian as an ellipse with optional cross hairs +% h=plotgauss2(mu, Sigma) +% + +h = plotcov2(mu, Sigma); +return; + +%%%%%%%%%%%%%%%%%%%%%%%% + +% PLOTCOV2 - Plots a covariance ellipse with major and minor axes +% for a bivariate Gaussian distribution. +% +% Usage: +% h = plotcov2(mu, Sigma[, OPTIONS]); +% +% Inputs: +% mu - a 2 x 1 vector giving the mean of the distribution. +% Sigma - a 2 x 2 symmetric positive semi-definite matrix giving +% the covariance of the distribution (or the zero matrix). +% +% Options: +% 'conf' - a scalar between 0 and 1 giving the confidence +% interval (i.e., the fraction of probability mass to +% be enclosed by the ellipse); default is 0.9. +% 'num-pts' - the number of points to be used to plot the +% ellipse; default is 100. +% +% This function also accepts options for PLOT. +% +% Outputs: +% h - a vector of figure handles to the ellipse boundary and +% its major and minor axes +% +% See also: PLOTCOV3 + +% Copyright (C) 2002 Mark A. Paskin + +function h = plotcov2(mu, Sigma, varargin) + +if size(Sigma) ~= [2 2], error('Sigma must be a 2 by 2 matrix'); end +if length(mu) ~= 2, error('mu must be a 2 by 1 vector'); end + +[p, ... + n, ... + plot_opts] = process_options(varargin, 'conf', 0.9, ... + 'num-pts', 100); +h = []; +holding = ishold; +if (Sigma == zeros(2, 2)) + z = mu; +else + % Compute the Mahalanobis radius of the ellipsoid that encloses + % the desired probability mass. + k = conf2mahal(p, 2); + % The major and minor axes of the covariance ellipse are given by + % the eigenvectors of the covariance matrix. Their lengths (for + % the ellipse with unit Mahalanobis radius) are given by the + % square roots of the corresponding eigenvalues. + if (issparse(Sigma)) + [V, D] = eigs(Sigma); + else + [V, D] = eig(Sigma); + end + % Compute the points on the surface of the ellipse. + t = linspace(0, 2*pi, n); + u = [cos(t); sin(t)]; + w = (k * V * sqrt(D)) * u; + z = repmat(mu, [1 n]) + w; + % Plot the major and minor axes. + L = k * sqrt(diag(D)); + h = plot([mu(1); mu(1) + L(1) * V(1, 1)], ... + [mu(2); mu(2) + L(1) * V(2, 1)], plot_opts{:}); + hold on; + h = [h; plot([mu(1); mu(1) + L(2) * V(1, 2)], ... + [mu(2); mu(2) + L(2) * V(2, 2)], plot_opts{:})]; +end + +h = [h; plot(z(1, :), z(2, :), plot_opts{:})]; +if (~holding) hold off; end + +%%%%%%%%%%%% + +% CONF2MAHAL - Translates a confidence interval to a Mahalanobis +% distance. Consider a multivariate Gaussian +% distribution of the form +% +% p(x) = 1/sqrt((2 * pi)^d * det(C)) * exp((-1/2) * MD(x, m, inv(C))) +% +% where MD(x, m, P) is the Mahalanobis distance from x +% to m under P: +% +% MD(x, m, P) = (x - m) * P * (x - m)' +% +% A particular Mahalanobis distance k identifies an +% ellipsoid centered at the mean of the distribution. +% The confidence interval associated with this ellipsoid +% is the probability mass enclosed by it. Similarly, +% a particular confidence interval uniquely determines +% an ellipsoid with a fixed Mahalanobis distance. +% +% If X is an d dimensional Gaussian-distributed vector, +% then the Mahalanobis distance of X is distributed +% according to the Chi-squared distribution with d +% degrees of freedom. Thus, the Mahalanobis distance is +% determined by evaluating the inverse cumulative +% distribution function of the chi squared distribution +% up to the confidence value. +% +% Usage: +% +% m = conf2mahal(c, d); +% +% Inputs: +% +% c - the confidence interval +% d - the number of dimensions of the Gaussian distribution +% +% Outputs: +% +% m - the Mahalanobis radius of the ellipsoid enclosing the +% fraction c of the distribution's probability mass +% +% See also: MAHAL2CONF + +% Copyright (C) 2002 Mark A. Paskin + +function m = conf2mahal(c, d) + +m = chi2inv(c, d); % matlab stats toolbox diff --git a/sourcecodes/bnt-master/KPMtools/plotgauss2d_old.m b/sourcecodes/bnt-master/KPMtools/plotgauss2d_old.m new file mode 100644 index 00000000..08d1d14d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/plotgauss2d_old.m @@ -0,0 +1,40 @@ +function h=plotgauss2d_old(mu, Sigma, plot_cross) +% PLOTGAUSS2D Plot a 2D Gaussian as an ellipse with optional cross hairs +% h=plotgauss2(mu, Sigma) +% +% h=plotgauss2(mu, Sigma, 1) also plots the major and minor axes +% +% Example +% clf; S=[2 1; 1 2]; plotgauss2d([0;0], S, 1); axis equal + +if nargin < 3, plot_cross = 0; end +[V,D]=eig(Sigma); +lam1 = D(1,1); +lam2 = D(2,2); +v1 = V(:,1); +v2 = V(:,2); +%assert(approxeq(v1' * v2, 0)) +if v1(1)==0 + theta = 0; % horizontal +else + theta = atan(v1(2)/v1(1)); +end +a = sqrt(lam1); +b = sqrt(lam2); +h=plot_ellipse(mu(1), mu(2), theta, a,b); + +if plot_cross + mu = mu(:); + held = ishold; + hold on + minor1 = mu-a*v1; minor2 = mu+a*v1; + hminor = line([minor1(1) minor2(1)], [minor1(2) minor2(2)]); + + major1 = mu-b*v2; major2 = mu+b*v2; + hmajor = line([major1(1) major2(1)], [major1(2) major2(2)]); + %set(hmajor,'color','r') + if ~held + hold off + end +end + diff --git a/sourcecodes/bnt-master/KPMtools/polygon_area.m b/sourcecodes/bnt-master/KPMtools/polygon_area.m new file mode 100644 index 00000000..43dffc77 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/polygon_area.m @@ -0,0 +1,22 @@ +function a = polygon_area(x,y) +% AREA Area of a planar polygon. +% AREA(X,Y) Calculates the area of a 2-dimensional +% polygon formed by vertices with coordinate vectors +% X and Y. The result is direction-sensitive: the +% area is positive if the bounding contour is counter- +% clockwise and negative if it is clockwise. +% +% See also TRAPZ. + +% Copyright (c) 1995 by Kirill K. Pankratov, +% kirill@plume.mit.edu. +% 04/20/94, 05/20/95 + + % Make polygon closed ............. +x = [x(:); x(1)]; +y = [y(:); y(1)]; + + % Calculate contour integral Int -y*dx (same as Int x*dy). +lx = length(x); +a = -(x(2:lx)-x(1:lx-1))'*(y(1:lx-1)+y(2:lx))/2; +a = abs(a); diff --git a/sourcecodes/bnt-master/KPMtools/polygon_centroid.m b/sourcecodes/bnt-master/KPMtools/polygon_centroid.m new file mode 100644 index 00000000..f3e3947f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/polygon_centroid.m @@ -0,0 +1,79 @@ +function [x0,y0] = centroid(x,y) +% CENTROID Center of mass of a polygon. +% [X0,Y0] = CENTROID(X,Y) Calculates centroid +% (center of mass) of planar polygon with vertices +% coordinates X, Y. +% Z0 = CENTROID(X+i*Y) returns Z0=X0+i*Y0 the same +% as CENTROID(X,Y). + +% Copyright (c) 1995 by Kirill K. Pankratov, +% kirill@plume.mit.edu. +% 06/01/95, 06/07/95 + +% Algorithm: +% X0 = Int{x*ds}/Int{ds}, where ds - area element +% so that Int{ds} is total area of a polygon. +% Using Green's theorem the area integral can be +% reduced to a contour integral: +% Int{x*ds} = -Int{x^2*dy}, Int{ds} = Int{x*dy} along +% the perimeter of a polygon. +% For a polygon as a sequence of line segments +% this can be reduced exactly to a sum: +% Int{x^2*dy} = Sum{ (x_{i}^2+x_{i+1}^2+x_{i}*x_{i+1})* +% (y_{i+1}-y_{i})}/3; +% Int{x*dy} = Sum{(x_{i}+x_{i+1})(y_{i+1}-y_{i})}/2. +% Similarly +% Y0 = Int{y*ds}/Int{ds}, where +% Int{y*ds} = Int{y^2*dx} = +% = Sum{ (y_{i}^2+y_{i+1}^2+y_{i}*y_{i+1})* +% (x_{i+1}-x_{i})}/3. + + % Handle input ...................... +if nargin==0, help centroid, return, end +if nargin==1 + sz = size(x); + if sz(1)==2 % Matrix 2 by n + y = x(2,:); x = x(1,:); + elseif sz(2)==2 % Matrix n by 2 + y = x(:,2); x = x(:,1); + else + y = imag(x); + x = real(x); + end +end + + % Make a polygon closed .............. +x = [x(:); x(1)]; +y = [y(:); y(1)]; + + % Check length ....................... +l = length(x); +if length(y)~=l + error(' Vectors x and y must have the same length') +end + + % X-mean: Int{x^2*dy} ................ +del = y(2:l)-y(1:l-1); +v = x(1:l-1).^2+x(2:l).^2+x(1:l-1).*x(2:l); +x0 = v'*del; + + % Y-mean: Int{y^2*dx} ................ +del = x(2:l)-x(1:l-1); +v = y(1:l-1).^2+y(2:l).^2+y(1:l-1).*y(2:l); +y0 = v'*del; + + % Calculate area: Int{y*dx} .......... +a = (y(1:l-1)+y(2:l))'*del; +tol= 2*eps; +if abs(a)<tol + disp(' Warning: area of polygon is close to 0') + a = a+sign(a)*tol+(~a)*tol; +end + % Multiplier +a = 1/3/a; + + % Divide by area ..................... +x0 = -x0*a; +y0 = y0*a; + +if nargout < 2, x0 = x0+i*y0; end diff --git a/sourcecodes/bnt-master/KPMtools/polygon_intersect.m b/sourcecodes/bnt-master/KPMtools/polygon_intersect.m new file mode 100644 index 00000000..9289f612 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/polygon_intersect.m @@ -0,0 +1,60 @@ +function [is,S] = isintpl(x1,y1,x2,y2) +% ISINTPL Check for intersection of polygons. +% [IS,S] = ISINTPL(X1,Y1,X2,Y2) Accepts coordinates +% X1,Y1 and X2, Y2 of two polygons. Returns scalar +% IS equal to 1 if these polygons intersect each other +% and 0 if they do not. +% Also returns Boolean matrix S of the size length(X1) +% by length(X2) so that {ij} element of which is 1 if +% line segments i to i+1 of the first polygon and +% j to j+1 of the second polygon intersect each other, +% 0 if they don't and .5 if they "touch" each other. + +% Copyright (c) 1995 by Kirill K. Pankratov, +% kirill@plume.mit.edu. +% 06/20/95, 08/25/95 + + + % Handle input ................................... +if nargin==0, help isintpl, return, end +if nargin<4 + error(' Not enough input arguments ') +end + + % Make column vectors and check sizes ............ +x1 = x1(:); y1 = y1(:); +x2 = x2(:); y2 = y2(:); +l1 = length(x1); +l2 = length(x2); +if length(y1)~=l1 | length(y2)~=l2 + error('(X1,Y1) and (X2,Y2) must pair-wise have the same length.') +end + + % Quick exit if empty +if l1<1 | l2<1, is = []; S = []; return, end + + % Check if their ranges are intersecting ......... +lim1 = [min(x1) max(x1)]'; +lim2 = [min(x2) max(x2)]'; +isx = interval(lim1,lim2); % X-ranges +lim1 = [min(y1) max(y1)]'; +lim2 = [min(y2) max(y2)]'; +isy = interval(lim1,lim2); % Y-ranges +is = isx & isy; +S = zeros(l2,l1); + +if ~is, return, end % Early exit if disparate limits + + % Indexing ....................................... +[i11,i12] = meshgrid(1:l1,1:l2); +[i21,i22] = meshgrid([2:l1 1],[2:l2 1]); +i11 = i11(:); i12 = i12(:); +i21 = i21(:); i22 = i22(:); + + % Calculate matrix of intersections .............. +S(:) = iscross([x1(i11) x1(i21)]',[y1(i11) y1(i21)]',... + [x2(i12) x2(i22)]',[y2(i12) y2(i22)]')'; + +S = S'; +is = any(any(S)); + diff --git a/sourcecodes/bnt-master/KPMtools/previewfig.m b/sourcecodes/bnt-master/KPMtools/previewfig.m new file mode 100644 index 00000000..6983699b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/previewfig.m @@ -0,0 +1,49 @@ +function f = previewfig(h,varargin) +%PREVIEWFIG Preview a figure to be exported using EXPORTFIG. +% F = PREVIEWFIG(H) creates a preview of H with the default +% EXPORTFIG options and returns the preview's figure handle in F. +% F = PREVIEWFIG(H,OPTIONS) creates a preview with OPTIONS as +% described in EXPORTFIG. +% PREVIEWFIG(...,PARAM1,VAL1,PARAM2,VAL2,...) creates a preview +% with the specified parameter-value pairs to H as described in +% EXPORTFIG. +% +% See also EXPORTFIG, APPLYTOFIG, RESTOREFIG. + +% Copyright 2000 Ben Hinkle +% Email bug reports and comments to bhinkle@mathworks.com + +filename = [tempname, '.png']; +args = {'resolution',0,'format','png'}; +if nargin > 1 + exportfig(h, filename, varargin{:}, args{:}); +else + exportfig(h, filename, args{:}); +end + +X = imread(filename,'png'); +height = size(X,1); +width = size(X,2); +delete(filename); +f = figure( 'Name', 'Preview', ... + 'Menubar', 'none', ... + 'NumberTitle', 'off', ... + 'Visible', 'off'); +image(X); +axis image; +ax = findobj(f, 'type', 'axes'); +axesPos = [0 0 width height]; +set(ax, 'Units', 'pixels', ... + 'Position', axesPos, ... + 'Visible', 'off'); +figPos = get(f,'Position'); +rootSize = get(0,'ScreenSize'); +figPos(3:4) = axesPos(3:4); +if figPos(1) + figPos(3) > rootSize(3) + figPos(1) = rootSize(3) - figPos(3) - 50; +end +if figPos(2) + figPos(4) > rootSize(4) + figPos(2) = rootSize(4) - figPos(4) - 50; +end +set(f, 'Position',figPos, ... + 'Visible', 'on'); diff --git a/sourcecodes/bnt-master/KPMtools/process_options.m b/sourcecodes/bnt-master/KPMtools/process_options.m new file mode 100644 index 00000000..5e17eb89 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/process_options.m @@ -0,0 +1,132 @@ +% PROCESS_OPTIONS - Processes options passed to a Matlab function. +% This function provides a simple means of +% parsing attribute-value options. Each option is +% named by a unique string and is given a default +% value. +% +% Usage: [var1, var2, ..., varn[, unused]] = ... +% process_options(args, ... +% str1, def1, str2, def2, ..., strn, defn) +% +% Arguments: +% args - a cell array of input arguments, such +% as that provided by VARARGIN. Its contents +% should alternate between strings and +% values. +% str1, ..., strn - Strings that are associated with a +% particular variable +% def1, ..., defn - Default values returned if no option +% is supplied +% +% Returns: +% var1, ..., varn - values to be assigned to variables +% unused - an optional cell array of those +% string-value pairs that were unused; +% if this is not supplied, then a +% warning will be issued for each +% option in args that lacked a match. +% +% Examples: +% +% Suppose we wish to define a Matlab function 'func' that has +% required parameters x and y, and optional arguments 'u' and 'v'. +% With the definition +% +% function y = func(x, y, varargin) +% +% [u, v] = process_options(varargin, 'u', 0, 'v', 1); +% +% calling func(0, 1, 'v', 2) will assign 0 to x, 1 to y, 0 to u, and 2 +% to v. The parameter names are insensitive to case; calling +% func(0, 1, 'V', 2) has the same effect. The function call +% +% func(0, 1, 'u', 5, 'z', 2); +% +% will result in u having the value 5 and v having value 1, but +% will issue a warning that the 'z' option has not been used. On +% the other hand, if func is defined as +% +% function y = func(x, y, varargin) +% +% [u, v, unused_args] = process_options(varargin, 'u', 0, 'v', 1); +% +% then the call func(0, 1, 'u', 5, 'z', 2) will yield no warning, +% and unused_args will have the value {'z', 2}. This behaviour is +% useful for functions with options that invoke other functions +% with options; all options can be passed to the outer function and +% its unprocessed arguments can be passed to the inner function. + +% Copyright (C) 2002 Mark A. Paskin +% +% This program is free software; you can redistribute it and/or modify +% it under the terms of the GNU General Public License as published by +% the Free Software Foundation; either version 2 of the License, or +% (at your option) any later version. +% +% This program is distributed in the hope that it will be useful, but +% WITHOUT ANY WARRANTY; without even the implied warranty of +% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +% General Public License for more details. +% +% You should have received a copy of the GNU General Public License +% along with this program; if not, write to the Free Software +% Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 +% USA. +%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% + +function [varargout] = process_options(args, varargin) + +% Check the number of input arguments +n = length(varargin); +if (mod(n, 2)) + error('Each option must be a string/value pair.'); +end + +% Check the number of supplied output arguments +if (nargout < (n / 2)) + error('Insufficient number of output arguments given'); +elseif (nargout == (n / 2)) + warn = 1; + nout = n / 2; +else + warn = 0; + nout = n / 2 + 1; +end + +% Set outputs to be defaults +varargout = cell(1, nout); +for i=2:2:n + varargout{i/2} = varargin{i}; +end + +% Now process all arguments +nunused = 0; +for i=1:2:length(args) + found = 0; + for j=1:2:n + if strcmpi(args{i}, varargin{j}) + varargout{(j + 1)/2} = args{i + 1}; + found = 1; + break; + end + end + if (~found) + if (warn) + warning(sprintf('Option ''%s'' not used.', args{i})); + args{i} + else + nunused = nunused + 1; + unused{2 * nunused - 1} = args{i}; + unused{2 * nunused} = args{i + 1}; + end + end +end + +% Assign the unused arguments +if (~warn) + if (nunused) + varargout{nout} = unused; + else + varargout{nout} = cell(0); + end +end diff --git a/sourcecodes/bnt-master/KPMtools/rand_psd.m b/sourcecodes/bnt-master/KPMtools/rand_psd.m new file mode 100644 index 00000000..c6fc6d32 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rand_psd.m @@ -0,0 +1,13 @@ +function M = rand_psd(d, d2, k) +% Create a random positive definite matrix of size d by d by k (k defaults to 1) +% M = rand_psd(d, d2, k) default: d2 = d, k = 1 + +if nargin<2, d2 = d; end +if nargin<3, k = 1; end +if d2 ~= d, error('must be square'); end + +M = zeros(d,d,k); +for i=1:k + A = rand(d); + M(:,:,i) = A*A'; +end diff --git a/sourcecodes/bnt-master/KPMtools/rectintC.m b/sourcecodes/bnt-master/KPMtools/rectintC.m new file mode 100644 index 00000000..0651519b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rectintC.m @@ -0,0 +1,22 @@ +function [overlap, normoverlap] = rectintC(A,B) +% +% A(i,:) = [x y w h] +% B(j,:) = [x y w h] +% overlap(i,j) = area of intersection +% normoverlap(i,j) = overlap(i,j) / min(area(i), area(j)) +% +% Same as built-in rectint, but faster and uses less memory (since avoids repmat). + + +leftA = A(:,1); +bottomA = A(:,2); +rightA = leftA + A(:,3); +topA = bottomA + A(:,4); + +leftB = B(:,1)'; +bottomB = B(:,2)'; +rightB = leftB + B(:,3)'; +topB = bottomB + B(:,4)'; + +verbose = 0; +[overlap, normoverlap] = rectintLoopC(leftA, rightA, topA, bottomA, leftB, rightB, topB, bottomB, verbose); diff --git a/sourcecodes/bnt-master/KPMtools/rectintLoopC.c b/sourcecodes/bnt-master/KPMtools/rectintLoopC.c new file mode 100644 index 00000000..1a106e04 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rectintLoopC.c @@ -0,0 +1,71 @@ + +#include "mex.h" +#include <stdio.h> + +#define MAX(x,y) ((x)>(y) ? (x) : (y)) +#define MIN(x,y) ((x)<(y) ? (x) : (y)) + +void mexFunction( + int nlhs, mxArray *plhs[], + int nrhs, const mxArray *prhs[] + ) +{ + int j,k,m,n,nzmax,*irs,*jcs, *irs2, *jcs2; + double *overlap, *overlap2, tmp, areaA, areaB; + double *leftA, *rightA, *topA, *bottomA; + double *leftB, *rightB, *topB, *bottomB; + double *verbose; + + m = MAX(mxGetM(prhs[0]), mxGetN(prhs[0])); + n = MAX(mxGetM(prhs[4]), mxGetN(prhs[4])); + /* printf("A=%d, B=%d\n", m, n); */ + + leftA = mxGetPr(prhs[0]); + rightA = mxGetPr(prhs[1]); + topA = mxGetPr(prhs[2]); + bottomA = mxGetPr(prhs[3]); + + leftB = mxGetPr(prhs[4]); + rightB = mxGetPr(prhs[5]); + topB = mxGetPr(prhs[6]); + bottomB = mxGetPr(prhs[7]); + + verbose = mxGetPr(prhs[8]); + + plhs[0] = mxCreateDoubleMatrix(m,n, mxREAL); + overlap = mxGetPr(plhs[0]); + + plhs[1] = mxCreateDoubleMatrix(m,n, mxREAL); + overlap2 = mxGetPr(plhs[1]); + + k = 0; + for (j = 0; (j < n); j++) { + int i; + for (i = 0; (i < m); i++) { + tmp = (MAX(0, MIN(rightA[i], rightB[j]) - MAX(leftA[i], leftB[j]) )) * + (MAX(0, MIN(topA[i], topB[j]) - MAX(bottomA[i], bottomB[j]) )); + + if (tmp > 0) { + overlap[k] = tmp; + + areaA = (rightA[i]-leftA[i])*(topA[i]-bottomA[i]); + areaB = (rightB[j]-leftB[j])*(topB[j]-bottomB[j]); + overlap2[k] = tmp/MIN(areaA, areaB); + + if (*verbose) { + printf("j=%d,i=%d,overlap=%5.3f, norm=%5.3f\n", j,i, overlap[k], overlap2[k]); + } + } + + k++; + } + } +} + + + + + + + + diff --git a/sourcecodes/bnt-master/KPMtools/rectintLoopC.dll b/sourcecodes/bnt-master/KPMtools/rectintLoopC.dll new file mode 100644 index 00000000..ab7750f6 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rectintLoopC.dll Binary files differdiff --git a/sourcecodes/bnt-master/KPMtools/rectintSparse.m b/sourcecodes/bnt-master/KPMtools/rectintSparse.m new file mode 100644 index 00000000..f2aa33a9 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rectintSparse.m @@ -0,0 +1,59 @@ +function [overlap, normoverlap] = rectintSparse(A,B) +% +% A(i,:) = [x y w h] +% B(j,:) = [x y w h] +% overlap(i,j) = area of intersection +% normoverla(i,j) +% +% Same as built-in rectint, but uses less memory. +% Use rectintSparseC for a faster version. +% + +leftA = A(:,1); +bottomA = A(:,2); +rightA = leftA + A(:,3); +topA = bottomA + A(:,4); + +leftB = B(:,1)'; +bottomB = B(:,2)'; +rightB = leftB + B(:,3)'; +topB = bottomB + B(:,4)'; + +numRectA = size(A,1); +numRectB = size(B,1); + +%out = rectintSparseLoopC(leftA, rightA, topA, bottomA, leftB, rightB, topB, bottomB); + +nnz = ceil(0.2*numRectA*numRectB); % guess of number of non-zeroes +overlap = sparse([], [], [], numRectA, numRectB, nnz); +normoverlap = sparse([], [], [], numRectA, numRectB, nnz); +for j=1:numRectB + for i=1:numRectA + tmp = (max(0, min(rightA(i), rightB(j)) - max(leftA(i), leftB(j)) ) ) .* ... + (max(0, min(topA(i), topB(j)) - max(bottomA(i), bottomB(j)) ) ); + if tmp>0 + overlap(i,j) = tmp; + areaA = (rightA(i)-leftA(i))*(topA(i)-bottomA(i)); + areaB = (rightB(j)-leftB(j))*(topB(j)-bottomB(j)); + normoverlap(i,j) = min(tmp/areaA, tmp/areaB); + end + %fprintf('j=%d, i=%d, overlap=%5.3f, norm=%5.3f\n',... + % j, i, overlap(i,j), normoverlap(i,j)); + end +end + + +if 0 +N = size(bboxDense01,2); % 1000; +rect = bboxToRect(bboxDense01)'; +A = rect(1:2,:); +B = rect(1:N,:); + +tic; out1 = rectint(A, B); toc +tic; out2 = rectintSparse(A, B); toc +tic; out3 = rectintSparseC(A, B); toc +tic; out4 = rectintC(A, B); toc +assert(approxeq(out1, out2)) +assert(approxeq(out1, full(out3))) +assert(approxeq(out1, out4)) +end diff --git a/sourcecodes/bnt-master/KPMtools/rectintSparseC.m b/sourcecodes/bnt-master/KPMtools/rectintSparseC.m new file mode 100644 index 00000000..401d7dc3 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rectintSparseC.m @@ -0,0 +1,32 @@ +function [overlap, normoverlap] = rectintSparseC(A,B) +% +% function [area, normarea] = rectintSparseC(A,B) +% A(i,:) = [x y w h] +% B(j,:) = [x y w h] +% out(i,j) = area of intersection +% +% Same as built-in rectint, but uses less memory. +% Also, returns area of overlap normalized by area of patch. +% See rectintSparse + +if isempty(A) | isempty(B) + overlap = []; + normoverlap = []; + return; +end + +leftA = A(:,1); +bottomA = A(:,2); +rightA = leftA + A(:,3); +topA = bottomA + A(:,4); + +leftB = B(:,1)'; +bottomB = B(:,2)'; +rightB = leftB + B(:,3)'; +topB = bottomB + B(:,4)'; + +numRectA = size(A,1); +numRectB = size(B,1); + +verbose = 0; +[overlap, normoverlap] = rectintSparseLoopC(leftA, rightA, topA, bottomA, leftB, rightB, topB, bottomB, verbose); diff --git a/sourcecodes/bnt-master/KPMtools/rectintSparseLoopC.c b/sourcecodes/bnt-master/KPMtools/rectintSparseLoopC.c new file mode 100644 index 00000000..38ed08d5 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rectintSparseLoopC.c @@ -0,0 +1,147 @@ +/* This is based on +http://www.mathworks.com/access/helpdesk/help/techdoc/matlab_external/ch04cr12.shtml + +See rectintSparse.m for the matlab version of this code. + +*/ + +#include <math.h> /* Needed for the ceil() prototype. */ +#include "mex.h" +#include <stdio.h> + +/* If you are using a compiler that equates NaN to be zero, you + * must compile this example using the flag -DNAN_EQUALS_ZERO. + * For example: + * + * mex -DNAN_EQUALS_ZERO fulltosparse.c + * + * This will correctly define the IsNonZero macro for your C + * compiler. + */ + +#if defined(NAN_EQUALS_ZERO) +#define IsNonZero(d) ((d) != 0.0 || mxIsNaN(d)) +#else +#define IsNonZero(d) ((d) != 0.0) +#endif + +#define MAX(x,y) ((x)>(y) ? (x) : (y)) +#define MIN(x,y) ((x)<(y) ? (x) : (y)) + +void mexFunction( + int nlhs, mxArray *plhs[], + int nrhs, const mxArray *prhs[] + ) +{ + /* Declare variables. */ + int j,k,m,n,nzmax,*irs,*jcs, *irs2, *jcs2; + double *overlap, *overlap2, tmp, areaA, areaB; + double percent_sparse; + double *leftA, *rightA, *topA, *bottomA; + double *leftB, *rightB, *topB, *bottomB; + double *verbose; + + /* Get the size and pointers to input data. */ + m = MAX(mxGetM(prhs[0]), mxGetN(prhs[0])); + n = MAX(mxGetM(prhs[4]), mxGetN(prhs[4])); + /* printf("A=%d, B=%d\n", m, n); */ + + leftA = mxGetPr(prhs[0]); + rightA = mxGetPr(prhs[1]); + topA = mxGetPr(prhs[2]); + bottomA = mxGetPr(prhs[3]); + + leftB = mxGetPr(prhs[4]); + rightB = mxGetPr(prhs[5]); + topB = mxGetPr(prhs[6]); + bottomB = mxGetPr(prhs[7]); + + verbose = mxGetPr(prhs[8]); + + /* Allocate space for sparse matrix. + * NOTE: Assume at most 20% of the data is sparse. Use ceil + * to cause it to round up. + */ + + percent_sparse = 0.01; + nzmax = (int)ceil((double)m*(double)n*percent_sparse); + + plhs[0] = mxCreateSparse(m,n,nzmax,0); + overlap = mxGetPr(plhs[0]); + irs = mxGetIr(plhs[0]); + jcs = mxGetJc(plhs[0]); + + plhs[1] = mxCreateSparse(m,n,nzmax,0); + overlap2 = mxGetPr(plhs[1]); + irs2 = mxGetIr(plhs[1]); + jcs2 = mxGetJc(plhs[1]); + + + /* Assign nonzeros. */ + k = 0; + for (j = 0; (j < n); j++) { + int i; + jcs[j] = k; + jcs2[j] = k; + for (i = 0; (i < m); i++) { + tmp = (MAX(0, MIN(rightA[i], rightB[j]) - MAX(leftA[i], leftB[j]) )) * + (MAX(0, MIN(topA[i], topB[j]) - MAX(bottomA[i], bottomB[j]) )); + + if (*verbose) { + printf("j=%d,i=%d,tmp=%5.3f\n", j,i,tmp); + } + + if (IsNonZero(tmp)) { + + /* Check to see if non-zero element will fit in + * allocated output array. If not, increase + * percent_sparse by 20%, recalculate nzmax, and augment + * the sparse array. + */ + if (k >= nzmax) { + int oldnzmax = nzmax; + percent_sparse += 0.2; + nzmax = (int)ceil((double)m*(double)n*percent_sparse); + + /* Make sure nzmax increases atleast by 1. */ + if (oldnzmax == nzmax) + nzmax++; + printf("reallocating from %d to %d\n", oldnzmax, nzmax); + + mxSetNzmax(plhs[0], nzmax); + mxSetPr(plhs[0], mxRealloc(overlap, nzmax*sizeof(double))); + mxSetIr(plhs[0], mxRealloc(irs, nzmax*sizeof(int))); + overlap = mxGetPr(plhs[0]); + irs = mxGetIr(plhs[0]); + + mxSetNzmax(plhs[1], nzmax); + mxSetPr(plhs[1], mxRealloc(overlap2, nzmax*sizeof(double))); + mxSetIr(plhs[1], mxRealloc(irs2, nzmax*sizeof(int))); + overlap2 = mxGetPr(plhs[1]); + irs2 = mxGetIr(plhs[1]); + } + + overlap[k] = tmp; + irs[k] = i; + + areaA = (rightA[i]-leftA[i])*(topA[i]-bottomA[i]); + areaB = (rightB[j]-leftB[j])*(topB[j]-bottomB[j]); + overlap2[k] = MIN(tmp/areaA, tmp/areaB); + irs2[k] = i; + + k++; + } /* IsNonZero */ + } /* for i */ + } + jcs[n] = k; + jcs2[n] = k; + +} + + + + + + + + diff --git a/sourcecodes/bnt-master/KPMtools/rectintSparseLoopC.dll b/sourcecodes/bnt-master/KPMtools/rectintSparseLoopC.dll new file mode 100644 index 00000000..ea535baa --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rectintSparseLoopC.dll Binary files differdiff --git a/sourcecodes/bnt-master/KPMtools/repmatC.c b/sourcecodes/bnt-master/KPMtools/repmatC.c new file mode 100644 index 00000000..6062772c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/repmatC.c @@ -0,0 +1,149 @@ +/* +mex -c mexutil.c +mex repmat.c mexutil.obj +to check for warnings: +gcc -Wall -I/cygdrive/c/MATLAB6p1/extern/include -c repmat.c +*/ +#include "mexutil.h" +#include <string.h> + +/* repeat a block of memory rep times */ +void memrep(char *dest, size_t chunk, int rep) +{ +#if 0 + /* slow way */ + int i; + char *p = dest; + for(i=1;i<rep;i++) { + p += chunk; + memcpy(p, dest, chunk); + } +#else + /* fast way */ + if(rep == 1) return; + memcpy(dest + chunk, dest, chunk); + if(rep & 1) { + dest += chunk; + memcpy(dest + chunk, dest, chunk); + } + /* now repeat using a block twice as big */ + memrep(dest, chunk<<1, rep>>1); +#endif +} + +void repmat(char *dest, const char *src, int ndim, int *destdimsize, + int *dimsize, const int *dims, int *rep) +{ + int d = ndim-1; + int i, chunk; + /* copy the first repetition into dest */ + if(d == 0) { + chunk = dimsize[0]; + memcpy(dest,src,chunk); + } + else { + /* recursively repeat each slice of src */ + for(i=0;i<dims[d];i++) { + repmat(dest + i*destdimsize[d-1], src + i*dimsize[d-1], + ndim-1, destdimsize, dimsize, dims, rep); + } + chunk = destdimsize[d-1]*dims[d]; + } + /* copy the result rep-1 times */ + memrep(dest,chunk,rep[d]); +} + +void mexFunction(int nlhs, mxArray *plhs[], + int nrhs, const mxArray *prhs[]) +{ + const mxArray *srcmat; + int ndim, *dimsize, eltsize; + const int *dims; + int ndimdest, *destdims, *destdimsize; + char *src, *dest; + int *rep; + int i,nrep; + int extra_rep = 1; + int empty; + + if(nrhs < 2) mexErrMsgTxt("Usage: xrepmat(A, [N M ...])"); + srcmat = prhs[0]; + if(mxIsSparse(srcmat)) { + mexErrMsgTxt("Sorry, can't handle sparse matrices yet."); + } + if(mxIsCell(srcmat)) { + mexErrMsgTxt("Sorry, can't handle cell arrays yet."); + } + ndim = mxGetNumberOfDimensions(srcmat); + dims = mxGetDimensions(srcmat); + eltsize = mxGetElementSize(srcmat); + + /* compute dimension sizes */ + dimsize = mxCalloc(ndim, sizeof(int)); + dimsize[0] = eltsize*dims[0]; + for(i=1;i<ndim;i++) dimsize[i] = dimsize[i-1]*dims[i]; + + /* determine repetition vector */ + ndimdest = ndim; + if(nrhs == 2) { + nrep = mxGetN(prhs[1]); + if(nrep > ndimdest) ndimdest = nrep; + rep = mxCalloc(ndimdest, sizeof(int)); + for(i=0;i<nrep;i++) { + double repv = mxGetPr(prhs[1])[i]; + rep[i] = (int)repv; + } + if(nrep == 1) { + /* special behavior */ + nrep = 2; + rep[1] = rep[0]; + } + } + else { + nrep = nrhs-1; + if(nrep > ndimdest) ndimdest = nrep; + rep = mxCalloc(ndimdest, sizeof(int)); + for(i=0;i<nrep;i++) { + rep[i] = (int)*mxGetPr(prhs[i+1]); + } + } + for(i=nrep;i<ndimdest;i++) rep[i] = 1; + + /* compute output size */ + destdims = mxCalloc(ndimdest, sizeof(int)); + for(i=0;i<ndim;i++) destdims[i] = dims[i]*rep[i]; + for(;i<ndimdest;i++) { + destdims[i] = rep[i]; + extra_rep *= rep[i]; + } + destdimsize = mxCalloc(ndim, sizeof(int)); + destdimsize[0] = eltsize*destdims[0]; + for(i=1;i<ndim;i++) destdimsize[i] = destdimsize[i-1]*destdims[i]; + + + /* for speed, array should be uninitialized */ + plhs[0] = mxCreateNumericArray(ndimdest, destdims, mxGetClassID(srcmat), + mxIsComplex(srcmat)?mxCOMPLEX:mxREAL); + + /* if any rep[i] == 0, output should be empty array. + Added by KPM 11/13/02. + */ + empty = 0; + for (i=0; i < nrep; i++) { + if (rep[i]==0) + empty = 1; + } + if (empty) + return; + + src = (char*)mxGetData(srcmat); + dest = (char*)mxGetData(plhs[0]); + repmat(dest,src,ndim,destdimsize,dimsize,dims,rep); + if(ndimdest > ndim) memrep(dest,destdimsize[ndim-1],extra_rep); + if(mxIsComplex(srcmat)) { + src = (char*)mxGetPi(srcmat); + dest = (char*)mxGetPi(plhs[0]); + repmat(dest,src,ndim,destdimsize,dimsize,dims,rep); + if(ndimdest > ndim) memrep(dest,destdimsize[ndim-1],extra_rep); + } +} diff --git a/sourcecodes/bnt-master/KPMtools/repmatC.dll b/sourcecodes/bnt-master/KPMtools/repmatC.dll new file mode 100644 index 00000000..3b9ed6cb --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/repmatC.dll Binary files differdiff --git a/sourcecodes/bnt-master/KPMtools/rgb2grayKPM.m b/sourcecodes/bnt-master/KPMtools/rgb2grayKPM.m new file mode 100644 index 00000000..e15434f0 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rgb2grayKPM.m @@ -0,0 +1,11 @@ +function g = rgb2grayKPM(rgb) +% function g = rgb2grayKPM(rgb) +% rgb2grayKPM Like the built-in function, but if r is already gray, does not cause an error + +[nr nc ncolors] = size(rgb); +if ncolors > 1 + g = rgb2gray(rgb); +else + g = rgb; +end + diff --git a/sourcecodes/bnt-master/KPMtools/rnd_partition.m b/sourcecodes/bnt-master/KPMtools/rnd_partition.m new file mode 100644 index 00000000..da01bf08 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rnd_partition.m @@ -0,0 +1,13 @@ +function [train, test] = rnd_partition(data, train_percent); +% function [train, test] = rnd_partition(data, train_percent); +% +% data(:,i) is the i'th example +% train_percent of these columns get put into train, the rest into test + +N = size(data, 2); +ndx = randperm(N); +k = ceil(N*train_percent); +train_ndx = ndx(1:k); +test_ndx = ndx(k+1:end); +train = data(:, train_ndx); +test = data(:, test_ndx); diff --git a/sourcecodes/bnt-master/KPMtools/rotate_xlabel.m b/sourcecodes/bnt-master/KPMtools/rotate_xlabel.m new file mode 100644 index 00000000..35f7c48c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/rotate_xlabel.m @@ -0,0 +1,37 @@ +function hText = rotate_xlabel(degrees, newlabels) + +% Posted to comp.soft-sys.matlab on 2003-05-01 13:45:36 PST +% by David Borger (borger@ix.netcom.com) + +xtl = get(gca,'XTickLabel'); +set(gca,'XTickLabel',''); +lxtl = length(xtl); +xtl = newlabels; +if 0 % nargin>1 + lnl = length(newlabels); + if lnl~=lxtl + error('Number of new labels must equal number of old'); + end; + xtl = newlabels; +end; + + +hxLabel=get(gca,'XLabel'); +xLP=get(hxLabel,'Position'); +y=xLP(2); +XTick=get(gca,'XTick'); +y=repmat(y,length(XTick),1); +%fs=get(gca,'fontsize'); +fs = 12; +hText=text(XTick,y,xtl,'fontsize',fs); +set(hText,'Rotation',degrees,'HorizontalAlignment','right'); + +% Modifications by KPM + +ylim = get(gca,'ylim'); +height = ylim(2)-ylim(1); +N = length(hText); +for i=1:N + voffset = ylim(2) - 0*height; + set(hText(i), 'position', [i voffset 0]); +end diff --git a/sourcecodes/bnt-master/KPMtools/safeStr.m b/sourcecodes/bnt-master/KPMtools/safeStr.m new file mode 100644 index 00000000..f775a2a9 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/safeStr.m @@ -0,0 +1,5 @@ +function s = safeStr(s) +% Change punctuation characters to they print properly + +s = strrep(s, '\', '/'); +s = strrep(s, '_', '-'); diff --git a/sourcecodes/bnt-master/KPMtools/sampleUniformInts.m b/sourcecodes/bnt-master/KPMtools/sampleUniformInts.m new file mode 100644 index 00000000..d4c6c1a4 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/sampleUniformInts.m @@ -0,0 +1,6 @@ +function M = sampleUniformInts(N, r, c) + +% M is an rxc matrix of integers in 1..N + +prob = normalize(ones(N,1)); +M = sample_discrete(prob, r, c); diff --git a/sourcecodes/bnt-master/KPMtools/sample_discrete.m b/sourcecodes/bnt-master/KPMtools/sample_discrete.m new file mode 100644 index 00000000..d8f6b687 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/sample_discrete.m @@ -0,0 +1,40 @@ +function M = sample_discrete(prob, r, c) +% SAMPLE_DISCRETE Like the built in 'rand', except we draw from a non-uniform discrete distrib. +% M = sample_discrete(prob, r, c) +% +% Example: sample_discrete([0.8 0.2], 1, 10) generates a row vector of 10 random integers from {1,2}, +% where the prob. of being 1 is 0.8 and the prob of being 2 is 0.2. + +n = length(prob); + +if nargin == 1 + r = 1; c = 1; +elseif nargin == 2 + c == r; +end + +R = rand(r, c); +M = ones(r, c); +cumprob = cumsum(prob(:)); + +if n < r*c + for i = 1:n-1 + M = M + (R > cumprob(i)); + end +else + % loop over the smaller index - can be much faster if length(prob) >> r*c + cumprob2 = cumprob(1:end-1); + for i=1:r + for j=1:c + M(i,j) = sum(R(i,j) > cumprob2)+1; + end + end +end + + +% Slower, even though vectorized +%cumprob = reshape(cumsum([0 prob(1:end-1)]), [1 1 n]); +%M = sum(R(:,:,ones(n,1)) > cumprob(ones(r,1),ones(c,1),:), 3); + +% convert using a binning algorithm +%M=bindex(R,cumprob); diff --git a/sourcecodes/bnt-master/KPMtools/set_xtick_label.m b/sourcecodes/bnt-master/KPMtools/set_xtick_label.m new file mode 100644 index 00000000..72f0f170 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/set_xtick_label.m @@ -0,0 +1,51 @@ +function set_xtick_label(tick_labels, angle, axis_label) +% SET_XTICK_LABEL Print the xtick labels at an angle instead of horizontally +% set_xtick_label(tick_labels, angle, axis_label) +% +% angle default = 90 +% axis_label default = '' +% +% This is derived from Solution Number: 5375 on mathworks.com +% See set_xtick_label_demo for an example + +if nargin < 2, angle = 90; end +if nargin < 3, axis_label = []; end + +% Reduce the size of the axis so that all the labels fit in the figure. +pos = get(gca,'Position'); +%set(gca,'Position',[pos(1), .2, pos(3) .65]) +%set(gca,'Position',[pos(1), 0, pos(3) .45]) +%set(gca,'Position',[pos(1), 0.1, pos(3) 0.5]) + +ax = axis; % Current axis limits +axis(axis); % Fix the axis limits +Yl = ax(3:4); % Y-axis limits + +%set(gca, 'xtick', 1:length(tick_labels)); +set(gca, 'xtick', 0.7:1:length(tick_labels)); +Xt = get(gca, 'xtick'); + +% Place the text labels +t = text(Xt,Yl(1)*ones(1,length(Xt)),tick_labels); +set(t,'HorizontalAlignment','right','VerticalAlignment','top', 'Rotation', angle); + +% Remove the default labels +set(gca,'XTickLabel','') + +% Get the Extent of each text object. This +% loop is unavoidable. +for i = 1:length(t) + ext(i,:) = get(t(i),'Extent'); +end + +% Determine the lowest point. The X-label will be +% placed so that the top is aligned with this point. +LowYPoint = min(ext(:,2)); + +% Place the axis label at this point +if ~isempty(axis_label) + Xl = get(gca, 'Xlim'); + XMidPoint = Xl(1)+abs(diff(Xl))/2; + tl = text(XMidPoint,LowYPoint, axis_label, 'VerticalAlignment','top', ... + 'HorizontalAlignment','center'); +end diff --git a/sourcecodes/bnt-master/KPMtools/set_xtick_label_demo.m b/sourcecodes/bnt-master/KPMtools/set_xtick_label_demo.m new file mode 100644 index 00000000..e7c71f80 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/set_xtick_label_demo.m @@ -0,0 +1,52 @@ + +% Generate some test data. Assume that the X-axis represents months. +x = 1:12; +y = 10*rand(1,length(x)); + +% Plot the data. +h = plot(x,y,'+'); + +% Add a title. +title('This is a title') + +% Set the X-Tick locations so that every other month is labeled. +Xt = 1:2:11; +Xl = [1 12]; +set(gca,'XTick',Xt,'XLim',Xl); + +% Add the months as tick labels. +months = ['Jan'; + 'Feb'; + 'Mar'; + 'Apr'; + 'May'; + 'Jun'; + 'Jul'; + 'Aug'; + 'Sep'; + 'Oct'; + 'Nov'; + 'Dec']; + +set_xtick_label(months(1:2:12, :), 90, 'xaxis label'); + + + +if 0 + + +% Generate some test data. Assume that the X-axis represents months. +x = 1:8; +y = 10*rand(1,length(x)); + +% Plot the data. +h = plot(x,y,'+'); + +S = subsets(1:3); +str = cell(1,8); +for i=1:2^3 + str{i} = num2str(S{i}); +end +set_xtick_label(str); + +end diff --git a/sourcecodes/bnt-master/KPMtools/setdiag.m b/sourcecodes/bnt-master/KPMtools/setdiag.m new file mode 100644 index 00000000..30bfa60a --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/setdiag.m @@ -0,0 +1,21 @@ +function M = setdiag(M, v) +% SETDIAG Set the diagonal of a matrix to a specified scalar/vector. +% M = set_diag(M, v) + +n = length(M); +if length(v)==1 + v = repmat(v, 1, n); +end + +% e.g., for 3x3 matrix, elements are numbered +% 1 4 7 +% 2 5 8 +% 3 6 9 +% so diagnoal = [1 5 9] + + +J = 1:n+1:n^2; +M(J) = v; + +%M = triu(M,1) + tril(M,-1) + diag(v); + diff --git a/sourcecodes/bnt-master/KPMtools/softeye.m b/sourcecodes/bnt-master/KPMtools/softeye.m new file mode 100644 index 00000000..29f45ee4 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/softeye.m @@ -0,0 +1,11 @@ +function M = softeye(K, p) +% SOFTEYE Make a stochastic matrix with p on the diagonal, and the remaining mass distributed uniformly +% M = softeye(K, p) +% +% M is a K x K matrix. + +M = p*eye(K); +q = 1-p; +for i=1:K + M(i, [1:i-1 i+1:K]) = q/(K-1); +end diff --git a/sourcecodes/bnt-master/KPMtools/sort_evec.m b/sourcecodes/bnt-master/KPMtools/sort_evec.m new file mode 100644 index 00000000..e934aa56 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/sort_evec.m @@ -0,0 +1,22 @@ +function [evec, evals] = sort_evec(temp_evec, temp_evals, N) + +if ~isvectorBNT(temp_evals) + temp_evals = diag(temp_evals); +end + +% Eigenvalues nearly always returned in descending order, but just +% to make sure..... +[evals perm] = sort(-temp_evals); +evals = -evals(1:N); +if evals == temp_evals(1:N) + % Originals were in order + evec = temp_evec(:, 1:N); + return +else + fprintf('sorting evec\n'); + % Need to reorder the eigenvectors + for i=1:N + evec(:,i) = temp_evec(:,perm(i)); + end +end + diff --git a/sourcecodes/bnt-master/KPMtools/splitLongSeqIntoManyShort.m b/sourcecodes/bnt-master/KPMtools/splitLongSeqIntoManyShort.m new file mode 100644 index 00000000..e96d45f8 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/splitLongSeqIntoManyShort.m @@ -0,0 +1,16 @@ +function short = splitLongSeqIntoManyShort(long, Tsmall) +% splitLongSeqIntoManyShort Put groups of columns into a cell array of narrower matrices +% function short = splitLongSeqIntoManyShort(long, Tsmall) +% +% long(:,t) +% short{i} = long(:,ndx1:ndx2) where each segment (except maybe the last) is of length Tsmall + +T = length(long); +Nsmall = ceil(T/Tsmall); +short = cell(Nsmall,1); + +t = 1; +for i=1:Nsmall + short{i} = long(:,t:min(T,t+Tsmall-1)); + t = t+Tsmall; +end diff --git a/sourcecodes/bnt-master/KPMtools/sprintf_intvec.m b/sourcecodes/bnt-master/KPMtools/sprintf_intvec.m new file mode 100644 index 00000000..673ab922 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/sprintf_intvec.m @@ -0,0 +1,9 @@ +function s = sprintf_intvec(v) +% SPRINTF_INTVEC Print a vector of ints as comma separated string, with no trailing comma +% function s = sprintf_intvec(v) +% +% e.g., sprintf_intvec(1:3) returns '1,2,3' + +s = sprintf('%d,', v); +s = s(1:end-1); + diff --git a/sourcecodes/bnt-master/KPMtools/sqdist.m b/sourcecodes/bnt-master/KPMtools/sqdist.m new file mode 100644 index 00000000..45d1b18b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/sqdist.m @@ -0,0 +1,29 @@ +function m = sqdist(p, q, A) +% SQDIST Squared Euclidean or Mahalanobis distance. +% SQDIST(p,q) returns m(i,j) = (p(:,i) - q(:,j))'*(p(:,i) - q(:,j)). +% SQDIST(p,q,A) returns m(i,j) = (p(:,i) - q(:,j))'*A*(p(:,i) - q(:,j)). + +% From Tom Minka's lightspeed toolbox + +[d, pn] = size(p); +[d, qn] = size(q); + +if nargin == 2 + + pmag = sum(p .* p, 1); + qmag = sum(q .* q, 1); + m = repmat(qmag, pn, 1) + repmat(pmag', 1, qn) - 2*p'*q; + %m = ones(pn,1)*qmag + pmag'*ones(1,qn) - 2*p'*q; + +else + + if isempty(A) | isempty(p) + error('sqdist: empty matrices'); + end + Ap = A*p; + Aq = A*q; + pmag = sum(p .* Ap, 1); + qmag = sum(q .* Aq, 1); + m = repmat(qmag, pn, 1) + repmat(pmag', 1, qn) - 2*p'*Aq; + +end diff --git a/sourcecodes/bnt-master/KPMtools/strmatch_multi.m b/sourcecodes/bnt-master/KPMtools/strmatch_multi.m new file mode 100644 index 00000000..c29f326d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/strmatch_multi.m @@ -0,0 +1,30 @@ +function [posns] = strmatch_multi(keys, strs) +% STRMATCH_MULTI Find where each key occurs in list of strings. +% [pos] = strmatch_multi(key, strs) where key is a string and strs is a cell array of strings +% works like the built-in command sequence pos = strmatch(key, strs, 'exact'), +% except that pos is the first occurrence of key in strs; if there is no occurence, pos is 0. +% +% [posns] = strmatch_multi(keys, strs), where keys is a cell array of strings, +% matches each element of keys. It loops over whichever is shorter, keys or strs. + +if ~iscell(keys), keys = {keys}; end +nkeys = length(keys); +posns = zeros(1, nkeys); +if length(keys) < length(strs) + for i=1:nkeys + %pos = strmatch(keys{i}, strs, 'exact'); + ndx = strcmp(keys{i}, strs); % faster + pos = find(ndx); + if ~isempty(pos) + posns(i) = pos(1); + end + end +else + for s=1:length(strs) + %ndx = strmatch(strs{s}, keys, 'exact'); + ndx = strcmp(strs{s}, keys); + ndx = find(ndx); + posns(ndx) = s; + end +end + diff --git a/sourcecodes/bnt-master/KPMtools/strmatch_substr.m b/sourcecodes/bnt-master/KPMtools/strmatch_substr.m new file mode 100644 index 00000000..7a1e431f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/strmatch_substr.m @@ -0,0 +1,28 @@ +function ndx = strmatch_substr(str, strs) +% STRMATCH_SUBSTR Like strmatch, except str can match any part of strs{i}, not just prefix. +% ndx = strmatch_substr(str, strs) +% +% Example: +% i = strmatch('max', {'max','minimax','maximum'}) +% returns i = [1; 3] since only 1 and 3 begin with max, but +% i = strmatch_substr('max', {'max','minimax','maximum'}) +% returns i = [1;2;3]; +% +% If str is also a cell array, it is like calling strmatch_substr several times +% and concatenating the results. +% Example: +% +% i = strmatch_substr({'foo', 'dog'}, {'foo', 'hoofoo', 'dog'}) +% returns i = [1;2;3] + +ndx = []; +if ~iscell(str), str = {str}; end +for j=1:length(str) + for i=1:length(strs) + %ind = strfind(strs{i}, str{j}); % not supported in 6.0 + ind = findstr(strs{i}, str{j}); + if ~isempty(ind) + ndx = [ndx; i]; + end + end +end diff --git a/sourcecodes/bnt-master/KPMtools/strsplit.m b/sourcecodes/bnt-master/KPMtools/strsplit.m new file mode 100644 index 00000000..695c1635 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/strsplit.m @@ -0,0 +1,53 @@ +function parts = strsplit(splitstr, str, option) +%STRSPLIT Split string into pieces. +% +% STRSPLIT(SPLITSTR, STR, OPTION) splits the string STR at every occurrence +% of SPLITSTR and returns the result as a cell array of strings. By default, +% SPLITSTR is not included in the output. +% +% STRSPLIT(SPLITSTR, STR, OPTION) can be used to control how SPLITSTR is +% included in the output. If OPTION is 'include', SPLITSTR will be included +% as a separate string. If OPTION is 'append', SPLITSTR will be appended to +% each output string, as if the input string was split at the position right +% after the occurrence SPLITSTR. If OPTION is 'omit', SPLITSTR will not be +% included in the output. + +% Author: Peter J. Acklam +% Time-stamp: 2004-09-22 08:48:01 +0200 +% E-mail: pjacklam@online.no +% URL: http://home.online.no/~pjacklam + + nargsin = nargin; + error(nargchk(2, 3, nargsin)); + if nargsin < 3 + option = 'omit'; + else + option = lower(option); + end + + splitlen = length(splitstr); + parts = {}; + + while 1 + + k = strfind(str, splitstr); + if isempty(k) + parts{end+1} = str; + break + end + + switch option + case 'include' + parts(end+1:end+2) = {str(1:k(1)-1), splitstr}; + case 'append' + parts{end+1} = str(1 : k(1)+splitlen-1); + case 'omit' + parts{end+1} = str(1 : k(1)-1); + otherwise + error(['Invalid option string -- ', option]); + end + + + str = str(k(1)+splitlen : end); + + end diff --git a/sourcecodes/bnt-master/KPMtools/subplot2.m b/sourcecodes/bnt-master/KPMtools/subplot2.m new file mode 100644 index 00000000..fb8c1c2f --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subplot2.m @@ -0,0 +1,17 @@ +function subplot2(nrows, ncols, i, j) +% function subplot2(nrows, ncols, i, j) + + +sz = [nrows ncols]; +%k = sub2ind(sz, i, j) +k = sub2ind(sz(end:-1:1), j, i); +subplot(nrows, ncols, k); + +if 0 + ncols_plot = ceil(sqrt(Nplots)); + nrows_plot = ceil(Nplots/ncols_plot); + Nplots = nrows_plot*ncols_plot; + for p=1:Nplots + subplot(nrows_plot, ncols_plot, p); + end +end diff --git a/sourcecodes/bnt-master/KPMtools/subplot3.m b/sourcecodes/bnt-master/KPMtools/subplot3.m new file mode 100644 index 00000000..0f8d1cc3 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subplot3.m @@ -0,0 +1,13 @@ +function fignum = subplot3(nrows, ncols, fignumBase, plotnumBase) +% function subplot3(nrows, ncols, fignumBase, plotnumBase) +% Choose a subplot number, opening a new figure if necessary +% eg nrows=2, ncols = 2, we plot on (fignum, plotnum) = (1,1), (1,2), (1,3), (1,4), (2,1), ... + +nplotsPerFig = nrows*ncols; +fignum = fignumBase + div(plotnumBase-1, nplotsPerFig); +plotnum = wrap(plotnumBase, nplotsPerFig); +figure(fignum); +if plotnum==1, clf; end +subplot(nrows, ncols, plotnum); + + diff --git a/sourcecodes/bnt-master/KPMtools/subsets.m b/sourcecodes/bnt-master/KPMtools/subsets.m new file mode 100644 index 00000000..47f999f0 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subsets.m @@ -0,0 +1,58 @@ +function [T, bitv] = subsets(S, U, L, sorted, N) +% SUBSETS Create a set of all the subsets of S which have cardinality <= U and >= L +% T = subsets(S, U, L) +% U defaults to length(S), L defaults to 0. +% So subsets(S) generates the powerset of S. +% +% Example: +% T = subsets(1:4, 2, 1) +% T{:} = 1, 2, [1 2], 3, [1 3], [2 3], 4, [1 4], [2 4], [3 4] +% +% T = subsets(S, U, L, sorted) +% If sorted=1, return the subsets in increasing size +% +% Example: +% T = subsets(1:4, 2, 1, 1) +% T{:} = 1, 2, 3, 4, [1 2], [1 3], [2 3], [1 4], [2 4], [3 4] +% +% [T, bitv] = subsets(S, U, L, sorted, N) +% Row i of bitv is a bit vector representation of T{i}, +% where bitv has N columns (representing 1:N). +% N defaults to max(S). +% +% Example: +% [T,bitv] = subsets(2:4, 2^3, 0, 0, 5) +% T{:} = [], 2, 3, [2 3], 4, [2 4], [3 4], [2 3 4] +% bitv= +% 0 0 0 0 0 +% 0 1 0 0 0 +% 0 0 1 0 0 +% 0 1 1 0 0 +% 0 0 0 1 0 +% 0 1 0 1 0 +% 0 0 1 1 0 +% 0 1 1 1 0 + +n = length(S); + +if nargin < 2, U = n; end +if nargin < 3, L = 0; end +if nargin < 4, sorted = 0; end +if nargin < 5, N = max(S); end + +bits = ind2subv(2*ones(1,n), 1:2^n)-1; +sm = sum(bits,2); +masks = bits((sm <= U) & (sm >= L), :); +m = size(masks, 1); +T = cell(1, m); +for i=1:m + s = S(find(masks(i,:))); + T{i} = s; +end + +if sorted + T = sortcell(T); +end + +bitv = zeros(m, N); +bitv(:, S) = masks; diff --git a/sourcecodes/bnt-master/KPMtools/subsets1.m b/sourcecodes/bnt-master/KPMtools/subsets1.m new file mode 100644 index 00000000..ca2bf46c --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subsets1.m @@ -0,0 +1,45 @@ +function sub_s=subsets1(s,k) +% SUBSETS1 creates sub-sets of a specific from a given set +% SS = subsets1(S, k) +% +% S is the given set +% k is the required sub-sets size +% +% Example: +% +% >> ss=subsets1([1:4],3); +% >> ss{:} +% ans = +% 1 2 3 +% ans = +% 1 2 4 +% ans = +% 1 3 4 +% ans = +% 2 3 4 +% +% Written by Raanan Yehezkel, 2004 + +if k<0 % special case + error('subset size must be positive'); +elseif k==0 % special case + sub_s={[]}; +else + l=length(s); + ss={}; + if l>=k + if k==1 % Exit condition + for I=1:l + ss{I}=s(I); + end + else + for I=1:l + ss1=subsets1(s([(I+1):l]),k-1); + for J=1:length(ss1) + ss{end+1}=[s(I),ss1{J}]; + end + end + end + end + sub_s=ss; +end diff --git a/sourcecodes/bnt-master/KPMtools/subsetsFixedSize.m b/sourcecodes/bnt-master/KPMtools/subsetsFixedSize.m new file mode 100644 index 00000000..26808e86 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subsetsFixedSize.m @@ -0,0 +1,45 @@ +function sub_s=subsets1(s,k) +% SUBSETS1 creates sub-sets of a specific size from a given set +% SS = subsets1(S, k) +% +% S is the given set +% k is the required sub-sets size +% +% Example: +% +% >> ss=subsets1([1:4],3); +% >> ss{:} +% ans = +% 1 2 3 +% ans = +% 1 2 4 +% ans = +% 1 3 4 +% ans = +% 2 3 4 +% +% Written by Raanan Yehezkel, 2004 + +if k<0 % special case + error('subset size must be positive'); +elseif k==0 % special case + sub_s={[]}; +else + l=length(s); + ss={}; + if l>=k + if k==1 % Exit condition + for I=1:l + ss{I}=s(I); + end + else + for I=1:l + ss1=subsets1(s([(I+1):l]),k-1); + for J=1:length(ss1) + ss{end+1}=[s(I),ss1{J}]; + end + end + end + end + sub_s=ss; +end diff --git a/sourcecodes/bnt-master/KPMtools/subv2ind.m b/sourcecodes/bnt-master/KPMtools/subv2ind.m new file mode 100644 index 00000000..dd50360d --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subv2ind.m @@ -0,0 +1,17 @@ +function index = subv2ind(siz,sub) +%SUBV2IND Linear index from subscript vector. +% SUBV2IND(SIZ,SUB) returns an equivalent single index corresponding to a +% subscript vector for an array of size SIZ. +% If SUB is a matrix, with subscript vectors as rows, then the result is a +% column vector. +% +% This is the opposite of IND2SUBV, so that +% SUBV2IND(SIZ,IND2SUBV(SIZ,IND)) == IND. +% +% See also IND2SUBV, SUB2IND. + +%index = subv2indTest(siz,sub); +prev_cum_size = [1 cumprod(siz(1:end-1))]; +%index = (sub-1)*prev_cum_size' + 1; +index = sub*prev_cum_size' - sum(prev_cum_size) + 1; + diff --git a/sourcecodes/bnt-master/KPMtools/subv2indKPM.c b/sourcecodes/bnt-master/KPMtools/subv2indKPM.c new file mode 100644 index 00000000..e1ecff42 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subv2indKPM.c @@ -0,0 +1,89 @@ +/* C mex version of subv2ind*/ +/* 2 inputs, 1 output */ +/* siz, subv */ +/* ndx */ +#include "mex.h" + +void mexFunction(int nlhs, mxArray *plhs[], int nrhs, const mxArray *prhs[]){ + int i, j, k, nCol, nRow, binary, temp; + double *pSize, *pSubv, *pr; + int *cumprod; + + pSize = mxGetPr(prhs[0]); + pSubv = mxGetPr(prhs[1]); + nCol = mxGetNumberOfElements(prhs[0]); + nRow = mxGetM(prhs[1]); + + + if(mxIsEmpty(prhs[1])){ + plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL); + return; + } + + if(mxIsEmpty(prhs[0])){ + plhs[0] = mxCreateDoubleMatrix(1, 1, mxREAL); + *mxGetPr(plhs[0]) = 1; + return; + } + + binary = 2; + for (i = 0; i < nCol; i++){ + if (pSize[i] > 2.0){ + binary = 0; + break; + } + else if(pSize[i] == 1.0){ + binary = 1; + } + } + + plhs[0] = mxCreateDoubleMatrix(nRow, 1, mxREAL); + pr = mxGetPr(plhs[0]); + for(i=0; i<nRow; i++){ + pr[i] = 1.0; + } + + if (binary == 2){ + for(j=0; j<nCol; j++){ + temp = j * nRow; + for(i=0; i<nRow; i++){ + pr[i] += ((int)pSubv[temp + i] - 1) << j; + } + } + } + else if(binary == 1){ + cumprod = malloc(nCol * sizeof(int)); + cumprod[0] = 1; + for(i=1; i<nCol; i++){ + k = (int)pSize[i-1] - 1; + cumprod[i] = cumprod[i-1] << k; + } + for(j=0; j<nCol; j++){ + temp = j * nRow; + for(i=0; i<nRow; i++){ + k = (int)pSubv[temp + i] - 1; + if(k)pr[i] += cumprod[j]; + } + } + free(cumprod); + } + else { + cumprod = malloc(nCol * sizeof(int)); + cumprod[0] = 1; + for(i=1; i<nCol; i++){ + k = (int)pSize[i-1]; + cumprod[i] = cumprod[i-1] * k; + } + for(j=0; j<nCol; j++){ + temp = j * nRow; + for(i=0; i<nRow; i++){ + k = (int)pSubv[temp + i] - 1; + pr[i] += cumprod[j] * k; + } + } + free(cumprod); + } +} + + + diff --git a/sourcecodes/bnt-master/KPMtools/subv2indKPM.m b/sourcecodes/bnt-master/KPMtools/subv2indKPM.m new file mode 100644 index 00000000..d0a16618 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subv2indKPM.m @@ -0,0 +1,66 @@ +function ndx = subv2indKPM(siz, subv) +% SUBV2IND Like the built-in sub2ind, but the subscripts are given as row vectors. +% ind = subv2ind(siz,subv) +% +% siz can be a row or column vector of size d. +% subv should be a collection of N row vectors of size d. +% ind will be of size N * 1. +% +% Example: +% subv = [1 1 1; +% 2 1 1; +% ... +% 2 2 2]; +% subv2ind([2 2 2], subv) returns [1 2 ... 8]' +% i.e., the leftmost digit toggles fastest. +% +% See also IND2SUBV. + + +if isempty(subv) + ndx = []; + return; +end + +if isempty(siz) + ndx = 1; + return; +end + +[ncases ndims] = size(subv); + +%if length(siz) ~= ndims +% error('length of subscript vector and sizes must be equal'); +%end + +if all(siz==2) + %rbits = subv(:,end:-1:1)-1; % read from right to left, convert to 0s/1s + %ndx = bitv2dec(rbits)+1; + twos = pow2(0:ndims-1); + ndx = ((subv-1) * twos(:)) + 1; + %ndx = sum((subv-1) .* twos(ones(ncases,1), :), 2) + 1; % equivalent to matrix * vector + %ndx = sum((subv-1) .* repmat(twos, ncases, 1), 2) + 1; % much slower than ones + %ndx = ndx(:)'; +else + %siz = siz(:)'; + cp = [1 cumprod(siz(1:end-1))]'; + %ndx = ones(ncases, 1); + %for i = 1:ndims + % ndx = ndx + (subv(:,i)-1)*cp(i); + %end + ndx = (subv-1)*cp + 1; +end + +%%%%%%%%%%% + +function d = bitv2dec(bits) +% BITV2DEC Convert a bit vector to a decimal integer +% d = butv2dec(bits) +% +% This is just like the built-in bin2dec, except the argument is a vector, not a string. +% If bits is an array, each row will be converted. + +[m n] = size(bits); +twos = pow2(n-1:-1:0); +d = sum(bits .* twos(ones(m,1),:),2); + diff --git a/sourcecodes/bnt-master/KPMtools/subv2indMinka.m b/sourcecodes/bnt-master/KPMtools/subv2indMinka.m new file mode 100644 index 00000000..cdb457b0 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subv2indMinka.m @@ -0,0 +1,17 @@ +function index = subv2indMinka(siz,sub) +%SUBV2IND Linear index from subscript vector. +% SUBV2IND(SIZ,SUB) returns an equivalent single index corresponding to a +% subscript vector for an array of size SIZ. +% If SUB is a matrix, with subscript vectors as rows, then the result is a +% column vector. +% +% This is the opposite of IND2SUBV, so that +% SUBV2IND(SIZ,IND2SUBV(SIZ,IND)) == IND. +% +% See also IND2SUBV, SUB2IND. + +% Written by Tom Minka + +prev_cum_size = [1 cumprod(siz(1:end-1))]; +%index = (sub-1)*prev_cum_size' + 1; +index = sub*prev_cum_size' - sum(prev_cum_size) + 1; diff --git a/sourcecodes/bnt-master/KPMtools/subv2indTest.m b/sourcecodes/bnt-master/KPMtools/subv2indTest.m new file mode 100644 index 00000000..e64ab947 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/subv2indTest.m @@ -0,0 +1,15 @@ +function ndx = subv2indTest(siz,sub) +%SUBV2IND Linear index from subscript vector. +% SUBV2IND(SIZ,SUB) returns an equivalent single index corresponding to a +% subscript vector for an array of size SIZ. +% If SUB is a matrix, with subscript vectors as rows, then the result is a +% column vector. +% +% This is the opposite of IND2SUBV, so that +% SUBV2IND(SIZ,IND2SUBV(SIZ,IND)) == IND. +% +% See also IND2SUBV, SUB2IND. + +ndx = subv2indMinka(siz,sub); +ndx2 = subv2indKPM(siz,sub); +assert(isequalKPM(ndx,ndx2)) diff --git a/sourcecodes/bnt-master/KPMtools/sumv.m b/sourcecodes/bnt-master/KPMtools/sumv.m new file mode 100644 index 00000000..4086cae9 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/sumv.m @@ -0,0 +1,11 @@ +function T2 = sumv(T1, sum_over) +% +% Like the built in sum, but will sum over several dimensions and then squeeze the result. + +T2 = T1; +for i=1:length(sum_over) + if sum_over(i) <= ndims(T2) % prevent summing over non-existent dimensions + T2=sum(T2, sum_over(i)); + end +end +T2 = squeeze(T2); diff --git a/sourcecodes/bnt-master/KPMtools/suptitle.m b/sourcecodes/bnt-master/KPMtools/suptitle.m new file mode 100644 index 00000000..fa12c541 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/suptitle.m @@ -0,0 +1,105 @@ +function hout=suptitle(str, fs) +%SUPTITLE Puts a title above all subplots. +% SUPTITLE('text') adds text to the top of the figure +% above all subplots (a "super title"). Use this function +% after all subplot commands. + +% Drea Thomas 6/15/95 drea@mathworks.com + +% Warning: If the figure or axis units are non-default, this +% will break. + +% Parameters used to position the supertitle. + +% Amount of the figure window devoted to subplots +plotregion = .92; + +% Y position of title in normalized coordinates +titleypos = .95; + +% Fontsize for supertitle +if nargin < 2 + fs = get(gcf,'defaultaxesfontsize')+4; +end + +% Fudge factor to adjust y spacing between subplots +fudge=1; + +haold = gca; +figunits = get(gcf,'units'); + +% Get the (approximate) difference between full height (plot + title +% + xlabel) and bounding rectangle. + + if (~strcmp(figunits,'pixels')), + set(gcf,'units','pixels'); + pos = get(gcf,'position'); + set(gcf,'units',figunits); + else, + pos = get(gcf,'position'); + end + ff = (fs-4)*1.27*5/pos(4)*fudge; + + % The 5 here reflects about 3 characters of height below + % an axis and 2 above. 1.27 is pixels per point. + +% Determine the bounding rectange for all the plots + +% h = findobj('Type','axes'); + +% findobj is a 4.2 thing.. if you don't have 4.2 comment out +% the next line and uncomment the following block. + +h = findobj(gcf,'Type','axes'); % Change suggested by Stacy J. Hills + +% If you don't have 4.2, use this code instead +%ch = get(gcf,'children'); +%h=[]; +%for i=1:length(ch), +% if strcmp(get(ch(i),'type'),'axes'), +% h=[h,ch(i)]; +% end +%end + + + + +max_y=0; +min_y=1; + +oldtitle =0; +for i=1:length(h), + if (~strcmp(get(h(i),'Tag'),'suptitle')), + pos=get(h(i),'pos'); + if (pos(2) < min_y), min_y=pos(2)-ff/5*3;end; + if (pos(4)+pos(2) > max_y), max_y=pos(4)+pos(2)+ff/5*2;end; + else, + oldtitle = h(i); + end +end + +if max_y > plotregion, + scale = (plotregion-min_y)/(max_y-min_y); + for i=1:length(h), + pos = get(h(i),'position'); + pos(2) = (pos(2)-min_y)*scale+min_y; + pos(4) = pos(4)*scale-(1-scale)*ff/5*3; + set(h(i),'position',pos); + end +end + +np = get(gcf,'nextplot'); +set(gcf,'nextplot','add'); +if (oldtitle), + delete(oldtitle); +end +ha=axes('pos',[0 1 1 1],'visible','off','Tag','suptitle'); +ht=text(.5,titleypos-1,str);set(ht,'horizontalalignment','center','fontsize',fs); +set(gcf,'nextplot',np); +axes(haold); +if nargout, + hout=ht; +end + + + diff --git a/sourcecodes/bnt-master/KPMtools/unaryEncoding.m b/sourcecodes/bnt-master/KPMtools/unaryEncoding.m new file mode 100644 index 00000000..ab0316a3 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/unaryEncoding.m @@ -0,0 +1,16 @@ +function U = unaryEncoding(data, K) +% unaryEncoding Encode data(s) as a 1-of-K column vector +% function U = unaryEncoding(data, K) +% +% eg. +% If data = [3 2 2] and K=3, +% then U = [0 0 0 +% 0 1 1 +% 1 0 0] + +if nargin < 2, K = max(data); end +N = length(data); +U = zeros(K,N); +ndx = subv2ind([K N], [data(:)'; 1:N]'); +U(ndx) = 1; +U = reshape(U, [K N]); diff --git a/sourcecodes/bnt-master/KPMtools/wrap.m b/sourcecodes/bnt-master/KPMtools/wrap.m new file mode 100644 index 00000000..9a5f2a2a --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/wrap.m @@ -0,0 +1,7 @@ +function v = wrap(u,N) +% WRAP Wrap a vector of indices around a torus. +% v = wrap(u,N) +% +% e.g., wrap([-1 0 1 2 3 4], 3) = 2 3 1 2 3 1 + +v = mod(u-1,N)+1; diff --git a/sourcecodes/bnt-master/KPMtools/xticklabel_rotate90.m b/sourcecodes/bnt-master/KPMtools/xticklabel_rotate90.m new file mode 100644 index 00000000..374c13b2 --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/xticklabel_rotate90.m @@ -0,0 +1,68 @@ +function xticklabel_rotate90(XTick,varargin) +%XTICKLABEL_ROTATE90 - Rotate numeric Xtick labels by 90 degrees +% +% Syntax: xticklabel_rotate90(XTick) +% +% Input: XTick - vector array of XTick positions & values (numeric) +% +% Output: none +% +% Example 1: Set the positions of the XTicks and rotate them +% figure; plot([1960:2004],randn(45,1)); xlim([1960 2004]); +% xticklabel_rotate90([1960:2:2004]); +% %If you wish, you may set a few text "Property-value" pairs +% xticklabel_rotate90([1960:2:2004],'Color','m','Fontweight','bold'); +% +% Example 2: %Rotate XTickLabels at their current position +% XTick = get(gca,'XTick'); +% xticklabel_rotate90(XTick); +% +% Other m-files required: none +% Subfunctions: none +% MAT-files required: none +% +% See also: TEXT, SET + +% Author: Denis Gilbert, Ph.D., physical oceanography +% Maurice Lamontagne Institute, Dept. of Fisheries and Oceans Canada +% email: gilbertd@dfo-mpo.gc.ca Web: http://www.qc.dfo-mpo.gc.ca/iml/ +% February 1998; Last revision: 24-Mar-2003 + +if ~isnumeric(XTick) + error('XTICKLABEL_ROTATE90 requires a numeric input argument'); +end + +%Make sure XTick is a column vector +XTick = XTick(:); + +%Set the Xtick locations and set XTicklabel to an empty string +set(gca,'XTick',XTick,'XTickLabel','') + +% Define the xtickLabels +xTickLabels = num2str(XTick); + +% Determine the location of the labels based on the position +% of the xlabel +hxLabel = get(gca,'XLabel'); % Handle to xlabel +xLabelString = get(hxLabel,'String'); + +if ~isempty(xLabelString) + warning('You may need to manually reset the XLABEL vertical position') +end + +set(hxLabel,'Units','data'); +xLabelPosition = get(hxLabel,'Position'); +y = xLabelPosition(2); + +%CODE below was modified following suggestions from Urs Schwarz +y=repmat(y,size(XTick,1),1); +% retrieve current axis' fontsize +fs = get(gca,'fontsize'); + +% Place the new xTickLabels by creating TEXT objects +hText = text(XTick, y, xTickLabels,'fontsize',fs); + +% Rotate the text objects by 90 degrees +set(hText,'Rotation',90,'HorizontalAlignment','right',varargin{:}) + +%------------- END OF CODE -------------- diff --git a/sourcecodes/bnt-master/KPMtools/zipload.m b/sourcecodes/bnt-master/KPMtools/zipload.m new file mode 100644 index 00000000..a66dbd1b --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/zipload.m @@ -0,0 +1,47 @@ +%ZIPLOAD Load compressed data file created with ZIPSAVE +% +% [data] = zipload( filename ) +% filename: string variable that contains the name of the +% compressed file (do not include '.zip' extension) +% Use only with files created with 'zipsave' +% pkzip25.exe has to be in the matlab path. This file is a compression utility +% made by Pkware, Inc. It can be dowloaded from: http://www.pkware.com +% Or directly from ftp://ftp.pkware.com/pk250c32.exe, for the Windows 95/NT version. +% This function was tested using 'PKZIP 2.50 Command Line for Windows 9x/NT' +% It is important to use version 2.5 of the utility. Otherwise the command line below +% has to be changed to include the proper options of the compression utility you +% wish to use. +% This function was tested in MATLAB Version 5.3 under Windows NT. +% Fernando A. Brucher - May/25/1999 +% +% Example: +% [loadedData] = zipload('testfile'); +%-------------------------------------------------------------------- + +function [data] = zipload( filename ) + +%--- Decompress data file by calling pkzip (comand line command) --- +% Options used: +% 'extract' = decompress file +% 'silent' = no console output +% 'over=all' = overwrite files + +%eval( ['!pkzip25 -extract -silent -over=all ', filename, '.zip'] ) +eval( ['!pkzip25 -extract -silent -over=all ', filename, '.zip'] ) + + +%--- Load data from decompressed file --- +% try, catch takes care of cases when pkzip fails to decompress a +% valid matlab format file + +try + tmpStruc = load( filename ); + data = tmpStruc.data; +catch, return, end + + +%--- Delete decompressed file --- + +delete( [filename,'.mat'] ) + + diff --git a/sourcecodes/bnt-master/KPMtools/zipsave.m b/sourcecodes/bnt-master/KPMtools/zipsave.m new file mode 100644 index 00000000..81f8b20e --- /dev/null +++ b/sourcecodes/bnt-master/KPMtools/zipsave.m @@ -0,0 +1,42 @@ +%ZIPSAVE Save data in compressed format +% +% zipsave( filename, data ) +% filename: string variable that contains the name of the resulting +% compressed file (do not include '.zip' extension) +% pkzip25.exe has to be in the matlab path. This file is a compression utility +% made by Pkware, Inc. It can be dowloaded from: http://www.pkware.com +% This function was tested using 'PKZIP 2.50 Command Line for Windows 9x/NT' +% It is important to use version 2.5 of the utility. Otherwise the command line below +% has to be changed to include the proper options of the compression utility you +% wish to use. +% This function was tested in MATLAB Version 5.3 under Windows NT. +% Fernando A. Brucher - May/25/1999 +% +% Example: +% testData = [1 2 3; 4 5 6; 7 8 9]; +% zipsave('testfile', testData); +% +% Modified by Kevin Murphy, 26 Feb 2004, to use winzip +%------------------------------------------------------------------------ + +function zipsave( filename, data ) + +%--- Save data in a temporary file in matlab format (.mat)--- + +eval( ['save ''', filename, ''' data'] ) + + +%--- Compress data by calling pkzip (comand line command) --- +% Options used: +% 'add' = add compressed files to the resulting zip file +% 'silent' = no console output +% 'over=all' = overwrite files + +%eval( ['!pkzip25 -silent -add -over=all ', filename, '.zip ', filename,'.mat'] ) +eval( ['!zip ', filename, '.zip ', filename,'.mat'] ) + +%--- Delete temporary matlab format file --- + +delete( [filename,'.mat'] ) + + |