Project in SciComp - Fall 2020

.gitignore

@@ -0,0 +1,31 @@
+# Windows default autosave extension
+*.asv
+
+# OSX / *nix default autosave extension
+*.m~
+
+# Compiled MEX binaries (all platforms)
+*.mex*
+
+# Packaged app and toolbox files
+*.mlappinstall
+*.mltbx
+
+# Generated helpsearch folders
+helpsearch*/
+
+# Simulink code generation folders
+slprj/
+sccprj/
+
+# Matlab code generation folders
+codegen/
+
+# Simulink autosave extension
+*.autosave
+
+# Simulink cache files
+*.slxc
+
+# Octave session info
+octave-workspace

startup.m

@@ -8,4 +8,9 @@
 
 % path to urdme/ folders
 addpath(genpath([link 'urdme/']));
-addpath(genpath([link 'workflows/']));
+addpath(genpath([link 'workflows/']));
+
+% Johannes Dufva 2020-10-30
+% path to other functions used
+% run('stenglib/make_all.m')
+run('stenglib/startup.m')

stenglib/Fast/clenshaw.m

@@ -0,0 +1,43 @@
+function Y = clenshaw(A,B,C)
+%CLENSHAW Evaluation of 3-term recurrences.
+%   Y = CLENSHAW(A,B) evaluates the 3-term recurrence as defined by the
+%   matrices A and B.
+%
+%   Let [M,N] be MAX(SIZE(A),SIZE(B)). Then the output Y is M-by-N and, for
+%   1 <= j <= N, the recurrence is defined by Y(1,j) = A(1,j)+B(1,j), Y(2,j)
+%   = A(2,j)*Y(1,j)+B(2,j) and, for i > 2, Y(i,j) =
+%   A(i,j)Y(i-1,j)+B(i,j)Y(i-2,j).
+%
+%   The dimensions of the matrices A and B must either match or be
+%   singletons. Singleton dimensions are as usual silently repeated.
+%
+%   Y = CLENSHAW(A,B,C) evaluates the 3-term recurrence defined by A and B,
+%   multiplies it by the coefficients C and computes the sum of the result
+%   by means of Clenshaws summation formula. C is M-by-K-by-N and the result
+%   is K-by-N. The first dimension of C must be M while the second and third
+%   dimensions of C can be singletons.
+%
+%   Examples:
+%     % Fibonacci numbers
+%     n = 10; clenshaw(1,[0; 0; ones(n-2,1)])'
+%
+%     % Legendre polynomials
+%     x = linspace(-1,1); n = 4; j = [0.5 1:n]';
+%     A = (2*j-1)./j*x;
+%     B = (1-j)./j;
+%     y = clenshaw(A,B);
+%     figure, plot(x,y);
+%
+%     % two functions defined by Chebyshev coefficients
+%     x = linspace(-1,1,50);
+%     n = 4; j = [0; 1; 2*ones(n-1,1)];
+%     A = j*x; B = [1; 0; -ones(n-1,1)];
+%     C = [[1 0.75 0.5 0.25 0.125]' [1 -1.75 1.5 -1.25 2.125]'];
+%     figure, plot(x,clenshaw(A,B,C));
+%
+%   See also FILTER.
+
+% S. Engblom 2007-04-19 (Major revision)
+% S. Engblom 2005-07-28
+
+error('.MEX-file not found on path.');

stenglib/Fast/frepmat.m

@@ -0,0 +1,61 @@
+function B = frepmat(A,rep)
+%FREPMAT Fast replication of array.
+%   FREPMAT does the same job as the MATLAB-function REPMAT but runs
+%   faster since the main part of the code is written in C.
+%
+%   B = FREPMAT(A,[M N]) creates a matrix B consisting of M-by-N
+%   copies of A.
+%
+%   In general, B = FREPMAT(A,REP) repeats A in the first dimension
+%   REP(1) times, in the second dimension REP(2) times and so on for
+%   all of the sizes in REP.
+%
+%   Unlike REPMAT, missing sizes in REP are consistently defined to be
+%   1. This means that if m is a scalar, then FREPMAT(A,m) does not
+%   produce the same result as REPMAT(A,m) (which is defined to be
+%   REPMAT(A,[m m])). Instead, FREPMAT(A,m) produces the same result
+%   as would REPMAT(A,[m 1]). Also, the traditional syntax
+%   FREPMAT(A,M,N,...) is not supported.
+%
+%   Examples:
+%     a = frepmat(1,1000);            % same as ones(1000,1)
+%     b = frepmat(int8(1),[100 100]); % same as ones(100,100,'int8')
+%
+%     s = sprand(10,10,0.5);
+%     a1 = frepmat(s,[100 10]); [nnz(a1) nzmax(a1)]
+%     a2 = repmat(s,[100 10]);  [nnz(a2) nzmax(a2)] % overallocation
+%
+%   See also REPMAT.
+
+%   - For doubles (real or complex), FREPMAT is about 15-20% faster
+%   than REPMAT.
+%
+%   - For other numerical types (single precision floats, integers,
+%   characters and logicals), FREPMAT is about 50% faster than REPMAT.
+%
+%   - For sparse matrices (real, complex or logical), FREPMAT is about
+%   85-95% faster than REPMAT and allocates much less memory.
+%
+%   - For other data-types, such as cell-, structure- and
+%   function-arrays, FREPMAT is about 10% faster than REPMAT.
+
+% S. Engblom 2004-10-28
+
+if isnumeric(A) || ischar(A) || islogical(A)
+  % runs fast
+  B = mexfrepmat(A,rep);
+else
+  % general code using the traditional 'indexing' style
+  rep = rep(:);
+  lenrep = size(rep,1);
+  len = max(lenrep,tndims(A));
+  sizA = int32(tsize(A,1:len));
+  rep = [rep; ones(len-lenrep,1)];
+
+  % while building the indices the speed of mexfrepmat is exploited
+  ix = cell(1,len);
+  for i = 1:len
+    ix{i} = mexfrepmat([1:sizA(i)]',rep(i));
+  end
+  B = A(ix{:});
+end

stenglib/Fast/fsetop.m

@@ -0,0 +1,102 @@
+function [c,ia,ib] = fsetop(op,a,b)
+%FSETOP Fast set operations based on hashing.
+%   FSETOP(OP,A,B) performs the set operation OP on the columns of the
+%   arrays A and B. The main differences from the set operations
+%   implemented in MATLAB are:
+%     - FSETOP runs faster because it is based on hashing instead of on
+%     sorting.
+%
+%     - In FSETOP, the order of the elements in the input arrays are
+%     retained in the output array, in contrast to the corresponding
+%     MATLAB functions where the result is sorted. This means that all
+%     indices for new elements are strictly increasing (except for IB
+%     in the INTERSECT operation and for JA and JB in the UNION
+%     operation). Also, in case of duplications, the first element
+%     (lowest column number) is selected.
+%
+%     - FSETOP always uses the columns of its inputs as elements, like the
+%     'rows' switch in the MATLAB commands, but for columns instead of
+%     rows. In particular, column vectors are not special cases, they are
+%     treated as single elements.
+%
+%     - FSETOP supports the following data types: double, single, char,
+%     logicals, int8, uint8, int16, uint16, int32, uint32, int64, uint64
+%     and cell-arrays containing any of the above data types.
+%
+%   Cell-arrays are treated as vectors and all output indices refer to a
+%   linear ordering. The output C is always a row cell-vector and cells
+%   containing the same data but of different types or shapes are
+%   considered unequal.
+%
+%   C = FSETOP('check',A) computes hash-values for each column in A. The
+%   output C is a row-vector containing uint32-type integers. This is not
+%   a set-operation but is provided as a useful tool for computing
+%   check-sums for large data-sets in a uniform way.
+%
+%   [C,IA,IB] = FSETOP('intersect',A,B) returns the columns common to
+%   both A and B. C = A(:,IA) = B(:,IB).
+%
+%   [C,IA] = FSETOP('setdiff',A,B) returns the columns in A that are
+%   not in B. C = A(:,IA).
+%
+%   [C,IA,IB] = FSETOP('setxor',A,B) returns the columns that are not
+%   in the intersection of A and B. C = [A(:,IA) B(:,IB)].
+%
+%   [C,IA,IB,JA,JB] = FSETOP('union',A,B) returns the combined columns
+%   from A and B but with no repetitions. C = [A(:,IA) B(:,IB)] and A
+%   = C(:,JA), B = C(:,JB). Note that the outputs JA and JB are not
+%   produced by the MATLAB-function UNION.
+%
+%   [B,IA,IB] = FSETOP('unique',A) returns the same columns as in A
+%   but with no repetitions. B = A(:,IA) and A = B(:,IB).
+%
+%   [IA,IB] = FSETOP('ismember',A,B) returns a logical vector IA
+%   containing 1 where the columns of A are also columns of B and 0
+%   otherwise. IB contains the index in B of each column in A and zero if
+%   no such index exists. A(:,IA) = B(:,IB(IA)).
+%
+%   Note: two elements are considered equal if and only if their
+%   bitwise representations are identical. This can sometimes give
+%   unexpected results. For example, with doubles, -0.0 ~= 0.0 and NaN
+%   == NaN.
+%
+%   Examples:
+%     % intersection of integers
+%     a = int8(ceil(3*rand(2,10))), b = int8(ceil(3*rand(2,10)))
+%     aandb = fsetop('intersect',a,b)
+%
+%     % unique strings in cell-array
+%     strs = {'foobar' 'foo' 'foobar' 'bar' 'barfoo'}
+%     strsunq = fsetop('unique',strs)
+%
+%     % find indices ix in b = a(ix)
+%     a = randperm(6), b = ceil(6*rand(1,6))
+%     [foo,ix] = fsetop('ismember',b,a)
+%
+%     % remove indices from set of indices
+%     a = {[1 2 4] [2 3 5 6] [4 2 1] [2 3 5 6]' int32([1 2 4])};
+%     b = {[4 2 1]};
+%     c = fsetop('setdiff',a,b)
+%
+%     % union of structs
+%     a = struct('foo',1,'bar',NaN,'foobar','hello')
+%     b = struct('faa',2,'bar',Inf,'foobar','goodbye')
+%     [cf,ia,ib] = fsetop('union',fieldnames(a),fieldnames(b));
+%     ac = struct2cell(a); bc = struct2cell(b);
+%     c = cell2struct([ac(ia); bc(ib)],cf)
+%
+%     % a single 32-bit checksum from strings
+%     s = {'check','intersect','setdiff','setxor', ...
+%          'union','unique','ismember'};
+%     c = fsetop('check',fsetop('check',s)')
+%
+%   See also INTERSECT, SETDIFF, SETXOR, UNION, UNIQUE, ISMEMBER.
+
+% S. Engblom 2010-02-09 (Revision)
+% S. Engblom 2006-06-13 (Major revision)
+% S. Engblom 2005-06-21
+% Based on a concept by P-O Persson, COMSOL AB. The internal hash
+% function used is based on a code by P. Hsieh, see
+% http://www.azillionmonkeys.com/qed/hash.html.
+
+error('.MEX-file not found on path.');