Build the Scharfetter-Gummel stabilized stiffness matrix for a diffusion-advection problem.

Build the UW stabilized stiffness matrix for an advection problem.

Build the Scharfetter-Gummel stabilized stiffness matrix for a diffusion-advection problem in cylindrical coordinates with axisymmetric configuration.

Build the Upwind stabilized stiffness matrix for an advection problem in cylindrical coordinates with axisymmetric configuration.

Build the standard finite element stiffness matrix for a diffusion problem in cylindrical coordinates with axisymmetric configuration.

Build the lumped finite element mass matrix for a diffusion problem in cylindrical coordinates with axisymmetric configuration.

Build the finite element right-hand side of a diffusion problem employing mass-lumping.

Build the standard finite element stiffness matrix for a diffusion problem.

Build the lumped finite element mass matrix for a diffusion problem.

Build the finite element right-hand side of a diffusion problem employing mass-lumping.

Compute interpolated values at nodes U_NOD given values at element mid-points U_EL.

Compute the NORM_TYPE-norm of function U on the domain described by the triangular grid MESH.

Build the Scharfetter-Gummel stabilized stiffness matrix for a diffusion-advection problem.

Build the UW stabilized stiffness matrix for an advection problem.

Build the Scharfetter-Gummel stabilized stiffness matrix for a diffusion-advection problem in cylindrical coordinates with axisymmetric configuration.

Build the Upwind stabilized stiffness matrix for an advection problem in cylindrical coordinates with axisymmetric configuration.

Build the lumped boundary mass matrix needed to apply Robin and Neumann boundary conditions in a problem in cylindrical coordinates with axisymmetric configuration.

Build the standard finite element stiffness matrix for a diffusion problem in cylindrical coordinates with axisymmetric configuration.

Build the lumped finite element mass matrix for a diffusion problem in cylindrical coordinates with axisymmetric configuration.

Build the finite element right-hand side of a diffusion problem in cylindrical coordinates with axisymmetric configuration employing mass-lumping.

Build the lumped boundary mass matrix needed to apply Robin boundary conditions.

Build the standard finite element stiffness matrix for a diffusion problem.

Build the lumped finite element mass matrix for a diffusion problem.

Build the finite element right-hand side of a diffusion problem employing mass-lumping.

Compute the flux associated with the Scharfetter-Gummel approximation of the scalar field U.

Compute interpolated values of multicomponent node centered field N_DATA and/or cell centered field N_DATA at an arbitrary set of points whose coordinates are given in the n_by_2 matrix POINTS.

Compute the properties of IMESH needed by BIM method and append them to OMESH as fields.

Compute the NORM_TYPE-norm of function U on the domain described by the triangular grid MESH.

Compute the gradient of the piecewise linear conforming scalar function U.

Compute interpolated values at triangle nodes U_NOD given values at triangle mid-points U_TRI.

Return the list of the mesh nodes that lie on the geometrical sides specified in SIDELIST.

Build the Scharfetter-Gummel stabilized stiffness matrix for a diffusion-advection problem.

Build the lumped boundary mass matrix needed to apply Robin boundary conditions.

Build the standard finite element stiffness matrix for a diffusion problem.

Build the Scharfetter-Gummel stabilized OSC stiffness matrix for a diffusion-advection problem.

Build the osc finite element stiffness matrix for a diffusion problem.

Build the lumped finite element mass matrix for a diffusion problem.

Build the finite element right-hand side of a diffusion problem employing mass-lumping.

Compute the flux associated with the Scharfetter-Gummel approximation of the scalar field U.

Compute interpolated values of node centered multicomponent node centered field N_DATA and cell centered field N_DATA at an arbitrary set of points whos coordinates are given in the n_by_3 matrix POIN

Compute the properties of IMESH needed by BIM method and append them to OMESH as fields.

Compute the NORM_TYPE-norm of function U on the domain described by the tetrahedral grid MESH.

Compute the gradient of the piecewise linear conforming scalar function U.

Compute interpolated values at triangle nodes U_NOD given values at tetrahedral centers of mass U_TRI.

Return the list of the mesh nodes that lie on the geometrical faces specified in FACELIST.

Compute the values of the Bernoulli function corresponding to X and - X arguments.

Input: - T1: - T2:

Absolute Value of the Differences (AVD) method.

This function creates the Co-occurrence matrix (COM)[1].

DATACUT is a function in graphic mode that selects and cuts a portion of data pack (DATA).

This function creates a data pack (3D matrix) from a set of images in a directory.

This function implements a convolution for each pixel of datapack.

This function save the images inside of datapack in a set of BMP files.

This function creates a gif file from the data pack (DATA).

This function implements a filter bank for each pixel of a datapack.

This function makes a step to synthesis filter bank for each pixel of datapacks DATA0 and DATA1.

This function makes a synthesis of a path in a filter bank, for each pixel of datapack DATA.

This function returns the modulus of frequency response of function H.

This function implements the Fujii Technique [1].

This function implements the Generalized Difference Technique [1].

This function returns a fir filter with an order and cut-off specified.

This function implements the Absolute Value of the Differences (AVD) method [1],
only using a pixel-by time, with the normalization of the co-occurrence matrix (COM)
proposed by CARDOSO, R

This function implements the Inertia Moment (IM) [1] method, only on a pixel-by time,
with the normalization of the co-occurrence matrix (COM) proposed by
CARDOSO, R.R.

This function calculates the temporal speckle kurtosis matrix (K).

This function implements the Motion History Image (MHI) technique [1-2], and considers a pixel as in activity, where it should have an absolute intensity jump superior to U.

This function implements the Parameterized form of Temporal Difference (PTD)
[1] technique.

This function implements the Regular Value of the Differences method [1],
only on a pixel-by time, with the normalization of the co-occurrence matrix (COM)
proposed by CARDOSO, R.R.

This function calculates the temporal speckle skewness matrix (S).

The function returns the binary entropy of a probability mass function.

Homogeneity of spatial variability [1].

This function save the images inside of datapack in a set of BMP files.

This function implements the Inertia Moment (IM) method [1].

This function divides the MAT matrix in windows of WLines lines and WColumns
columns, then in each one of these windows it is calculated the mean value of all
elements.

Numerical analysis of the modified AVD method [1].

The probability mass function of absolute difference (PMFAD) represents the probabilities of a random variable Z, being $Z=|i-j|$.

The probability mass function of regular difference (PMFRD) represents the probabilities of a random variable W, being $W=(i-j)$.

This function returns a vector with the parameters of a FIR filter with cut-off in pi/2 (for a 2*pi normalized frequency range).

This function returns the vector H1, the quadrature mirror filter of H0.

Regular Value of the Differences (RVD) method [1].

Saturation and sub-exposition of light[1].

This function select a set of M points, selected according to Type, in DATA(:,:,1), and through DATA(:,:,k)

Spatial speckle contrast window [1] method.

This function implements the temporal speckle contrast matrix [1], the temporal
speckle standard deviation matrix and the temporal speckle mean matrix.

This function implements the spatial-temporal speckle correlation [1]
technique.

It is a function that returns a matrix X with elements smaller than U.

This function creates the THSP (Time History Speckle Pattern)[1][2] of a set
of pixels in a line or column of a datapack (DATA).

This function implements the space-time speckle correlation [1]
technique.

This function creates the THSP (Time History Speckle Pattern)[1][2]
of a set of M points (pixels) randomly (Gaussian) selected in EXAMPLE_MATRIX,
and through DATA(:,:,k) for all k value.

This function creates the THSP (Time History Speckle Pattern)[1][2] of a set
of pixels in a line in a data pack (DATA), (This function is an alias of
thsp() function).

This function evaluates the THSP (Time History Speckle Patterns) of a set points selected in DATA(:,:,1), and through DATA(:,:,k) for all k value.

This function creates the THSP (Time History Speckle Pattern)[1][2] of a set
of M points (pixels) randomly (Uniform) selected in DATA(:,:,1), and through
DATA(:,:,k) for all k value.

Baseband demodulator for analog signals.

For a vector argument, return true (logical 1) if all elements of the vector are nonzero.

Compute the amplitude demodulation of the signal S with a carrier frequency of FC and a sample frequency of FS.

Create the AM modulation of the signal x with carrier frequency fs.

Baseband modulator for analog signals.

For a vector argument, return true (logical 1) if any element of the vector is nonzero.

Plots a ASK/PSK signal constellation.

Add white Gaussian noise to a voltage signal.

Decodes the coded message CODE using a BCH coder.

Encodes the message MSG using a [N,K] BCH coding.

Calculates the generator polynomials for a BCH coder.

Convert bit matrix to a vector of integers

Compares two matrices and returns the number of bit errors and the bit error rate.

Send DATA into a binary symmetric channel with probability P of error one each symbol.

Manual and test code for the Octave Communications toolbox.

Compresses and expanding the dynamic range of a signal using a mu-law or or A-law algorithm.

Convolve two vectors A and B.

Encode the binary vector MSG with the convolutional encoder described by the trellis structure T.

If A is a column vector and X is a column vector of length N, then

Finds the elements of GF(2^M) with primitive polynomial PRIM, that share the same minimum polynomial.

Produce the parity check and generator matrix of a cyclic code.

This function returns the cyclic generator polynomials of the code [N,K].

Convert a non-negative integer to bit vector.

Top level block decoder.

Deconvolve two vectors.

Restore elements of DATA according to ELEMENTS.

Demapping of an analog signal to a digital signal.

Compute the determinant of A.

Compute the N-by-N Fourier transformation matrix.

Return a diagonal matrix with vector V on diagonal K.

Decode using differential pulse code modulation (DPCM).

Encode using differential pulse code modulation (DPCM).

Optimize the DPCM parameters and codebook.

Decode Extended Golay code.

Encode with Extended Golay code.

Extended Golay code generator matrix.

Top level block encoder.

Compute 'e^x' for each element of X.

Plot the eye-diagram of a signal.

Compute the discrete Fourier transform of A using a Fast Fourier Transform (FFT) algorithm.

Returns the decoded Fibonacci value from the binary vectors CODE.

Returns the cell-array of encoded Fibonacci value from the column vectors NUM.

Returns the split data stream at the word boundaries.

Return the solution to the following linear, time-invariant difference equation:

Create the FM demodulation of the signal x with carrier frequency fs.

Create the FM modulation of the signal x with carrier frequency fs.

Converts binary generator matrix GEN to the parity check matrix PAR and visa-versa.

General quadrature amplitude demodulation.

Modulates an information sequence of integers X in the range '[0 ...

Creates a Galois field array GF(2^M) from the matrix X.

This function exists for compatibility with matlab.

Calculate the minimum weight or distance of a linear block code.

Returns the Golomb decoded signal vector using CODE and M.

Returns the Golomb coded signal as cell array.

Produce the parity check and generator matrices of a Hamming code.

NROWS-by-NCOLS.

Decode signal encoded by 'huffmanenco'.

Builds a Huffman code, given a probability list.

Returns the Huffman encoded signal using DICT.

Compute the inverse discrete Fourier transform of A using a Fast Fourier Transform (FFT) algorithm.

Interleaved elements of DATA according to ELEMENTS.

Compute the inverse of the square matrix A.

Compute the inverse of the square matrix A.

Return true if A is an empty matrix (any one of its dimensions is zero).

Return true if all of X1, X2, ...

Return 1 if the value of the expression EXPR is a Galois Field.

Returns 1 is the polynomial represented by A is a primitive polynomial of GF(2).

Return true if T is a valid trellis structure.

Return the length of the object A.

Optimize the quantization table and codes to reduce distortion.

Compute the natural logarithm, 'ln (X)', for each element of X.

Compute the LU decomposition of A.

Lempel-Ziv 77 source algorithm decoding implementation.

Lempel-Ziv 77 source algorithm implementation.

Restore elements of DATA with a temporary matrix of size NROWS-by-NCOLS.

Interleaved elements of DATA with a temporary matrix of size NROWS-by-NCOLS.

Finds the minimum polynomial for elements of a Galois Field.

Mapping of a digital signal to an analog signal.

Convert octal to decimal values.

Demodulates a pulse amplitude modulated signal X into an information sequence of integers in the range '[0 ...

Modulates an information sequence of integers X in the range '[0 ...

Convert convolutional code generator polynomials into trellis form.

Evaluate the polynomial P at the specified values of X.

Finds the primitive polynomials in GF(2^M).

Product of elements along dimension DIM.

Demodulates a complex-baseband phase shift keying modulated signal into an information sequence of integers in the range '[0 ...

Modulates an information sequence of integers X in the range '[0 ...

Create the QAM demodulation of x with a size of alphabet m.

Create the QAM modulation of x with a size of alphabet m.

Demaps an analog signal using a square QASK constellation.

Map a digital signal using a square QASK constellation.

Compute the Q function.

Compute the inverse Q function.

Quantization of an arbitrary signal relative to a partitioning.

Restore elements of DATA with a random permutation.

Generate a matrix of random bit errors.

Generate a matrix of random binary numbers.

Interleaves elements of DATA with a random permutation.

Generate a matrix of random symbols.

Compute the rank of matrix A, using the singular value decomposition.

Decode the received code word VV using the RM-generator matrix G, of order R, M, returning the code-word C.

Definition type construction of Reed-Muller code, of order R, length 2^M.

Definition type construction of Reed-Muller code, of order R, length 2^M.

Return a matrix with the specified dimensions (M, N, ...) whose elements are taken from the matrix A.

Returns the Rice decoded signal vector using CODE and K.

Returns the Rice encoded signal using K or optimal K .

Returns decoded run-length MESSAGE.

Returns run-length encoded MESSAGE.

For a vector V with N components, return the roots of the polynomial

Decodes the message contained in CODE using a [N,K] Reed-Solomon code.

Decodes an ASCII file using a Reed-Solomon coder.

Encodes the message MSG using a [N,K] Reed-Solomon coding.

Encodes an ASCII file using a Reed-Solomon coder.

Creates a generator polynomial for a Reed-Solomon coding with message length of K and codelength of N.

Display the scatter plot of a signal.

Returns the original signal that was Shannon-Fano encoded.

Returns the code dictionary for source using Shannon-Fano algorithm.

Returns the Shannon-Fano encoded signal using DICT.

Return the number of rows and columns of A.

Compute the square root of each element of X.

Sum of elements along dimension DIM.

Sum of squares of elements along dimension DIM.

Compares two matrices and returns the number of symbol errors and the symbol error rate.

Create the syndrome decoding table from the parity check matrix H.

Given G, extract P parity check matrix.

Converts the vector V into a C column matrix with row priority arrangement and with the final column padded with the value D to the correct length.

Returns a M-by-N matrix Y of white Gaussian noise.

Frequency-weighted coprime factorization controller reduction.

Model of the BMW 4-cylinder engine at ETH Zurich's control laboratory.

Creates a linearized state-space model of a Boeing 707-321 aircraft at V=80 m/s (M = 0.26, GA0 = -3 deg, ALPHA0 = 4 deg, KAPPA = 50 deg).

Robust control of a mass-damper-spring system.

Demonstration of frequency-weighted controller reduction.

Calculations on a two stage preamp for a multi-turn, air-core solenoid loop antenna for the reception of signals below 30kHz.

Model of the Westland Lynx Helicopter about hover.

Group LTI models by appending their inputs and outputs.

Estimate ARX model using QR factorization.

Append state vector x of system SYS to output vector y.

Extend plant for stacked S/KS/T problem.

Bode diagram of frequency response.

Bode magnitude diagram of frequency response.

Model order reduction by Balanced Stochastic Truncation (BST) method.

Controller reduction by frequency-weighted Balanced Truncation Approximation (BTA).

Model order reduction by frequency weighted Balanced Truncation Approximation (BTA) method.

Solve continuous-time algebraic Riccati equation (ARE).

Reduction of state-feedback-observer based controller by coprime factorization (CF).

Return the steady-state covariance.

Return controllability matrix.

If Co=ctrb(A,B) has rank r <= n = SIZE(A,1), then there is a similarity transformation Tc such that Tc = [t1 t2] where t1 is the controllable subspace and t2 is orthogonal to t1

Solve discrete-time algebraic Riccati equation (ARE).

Convert Decibels (dB) to Magnitude.

Kalman filter for discrete-time systems.

Linear-quadratic regulator for discrete-time systems.

Solve discrete-time Lyapunov or Sylvester equations.

Compute Cholesky factor of discrete-time Lyapunov equations.

Create or convert to descriptor state-space model.

Return state estimator for a given estimator gain.

Create discrete-time transfer function model from data in DSP format.

Fit frequency response data with a state-space system.

Create or convert to frequency response data.

Reduction of state-feedback-observer based controller by frequency-weighted coprime factorization (FW CF).

Generate periodic signal.

`gram (SYS, "c")' returns the controllability gramian of the (continuous- or discrete-time) system SYS.

H-2 control synthesis for LTI plant.

H-infinity control synthesis for LTI plant.

Model order reduction by frequency weighted optimal Hankel-norm (HNA) method.

Hankel singular values of the stable part of an LTI model.

Create identification dataset of output and input signals.

Impulse response of LTI system.

Initial condition response of state-space model.

Logical check for system controllability.

Logical test for system detectability.

Logical check for system observability.

Logical check for system stabilizability.

Design Kalman estimator for LTI systems.

Kalman filter for continuous-time systems.

Linear-quadratic regulator.

Simulate LTI model response to arbitrary inputs.

Solve continuous-time Lyapunov or Sylvester equations.

Compute Cholesky factor of continuous-time Lyapunov equations.

Convert Magnitude to Decibels (dB).

Gain and phase margin of a system.

Solve stacked S/KS/T H-infinity problem.

Partition LTI plant P for robust controller synthesis.

Estimate state-space model using combined subspace method: MOESP algorithm for finding the matrices A and C, and N4SID algorithm for finding the matrices B and D.

Estimate state-space model using MOESP algorithm.

Estimate state-space model using N4SID algorithm.

Loop shaping H-infinity synthesis.

Nichols chart of frequency response.

Nyquist diagram of frequency response.

Return observability matrix.

If Ob=obsv(A,C) has rank r <= n = SIZE(A,1), then there is a similarity transformation Tc such that To = [t1;t2] where t1 is c and t2 is orthogonal to t1

Numerical optimization of a PID controller using an objective function.

Create options struct OPT from a number of key and value pairs.

Return the transfer function C of the PID controller in parallel form with first-order roll-off.

Return the transfer function C of the PID controller in standard form with first-order roll-off.

Pole assignment for a given matrix pair (A,B) such that `p = eig (A-B*F)'.

Plot the poles and zeros of an LTI system in the complex plane.

Ramp response of LTI system.

Form a block transfer matrix of SYS with M copies vertically and N copies horizontally.

Display root locus plot of the specified SISO system.

Return sensitivity margin MS.

Singular values of frequency response.

Controller reduction by frequency-weighted Singular Perturbation Approximation (SPA).

Model order reduction by frequency weighted Singular Perturbation Approximation (SPA).

Create or convert to state-space model.

Step response of LTI system.

Return a cell vector of indexed strings by appending the indices IDX to the string STR.

Create summing junction S from string FORMULA for name-based interconnections.

Execute all available tests at once.

Create or convert to transfer function model.

Approximation of continuous-time delay using a discrete-time allpass Thiran filter.

Create transfer function model from zero-pole-gain data.

Compute divided differencing matrix of order O

Smooths the Y vs.

Smooths Y vs.

Wrapper function for rgdtsmcore in order to minimize over LAMBDA w.

Restore variable values from uint8 arrays generated with 'var2bytea'.

Show database package documentation.

Return a specific setting from a structure created by 'setdbopts'.

Closes connection CONNECTION to a postgresql server.

Establishes a connection to a postgresql server according to SETTINGS and returns an 'octave_pq_connection' object CONNECTION which can be passed to other functions of the package.

Retrieves connection information for postgresql connection CONNECTION, specified by the string LABEL, and returns the value of this information in VAL.

Sends the string COMMAND, which must contain a single SQL command, over the connection CONNECTION.

Exports the large object of Oid OID in the database associated with CONNECTION to the file PATH on the client side.

Imports the file in PATH on the client side as a large object into the database associated with CONNECTION and returns the Oid of the new large object.

Removes the large object of Oid OID from the database associated with CONNECTION.

Exports the large object of Oid OID in the database associated with CONNECTION to a temporary file and starts the program VIEWER in the background with the name of the temporary file as argument.

Updates information on existing postgresql types for CONNECTION.

Create settings structure for database functions.

Save input values in uint8 arrays in Octaves binary save format.

Get or set the active dicom data dictionary.

Get all data from a DICOM file, excluding any actual image.

Lookup an attribute in the DICOM data dictionary.

Load the image from a DICOM file.

Generate a DICOM unique id .

Write a DICOM format file to FILENAME.

Return true if FILENAME is a valid DICOM file.

Concatenate a cell array.

Display a message in a color (followed by a newline).

Display a message in a color (without a newline).

Solve a linear system with the preconditioned conjugated-gradient method.

Compute a variational analysis of arbitrarily located observations.

Add a constraint to the cost function.

Form the inverse of the background error covariance matrix.

Form the different components of the background error covariance matrix.

Create the advection constrain.

Computes diagnostics for the analysis.

Include constraint from EOFs.

Compute the expected error variance of the analysis.

Factorize some matrices to increase performance.

Return the analytical kernel and normalization factor.

Create the laplacian operator.

Compute metric scale factors.

Include the constrain from the observations.

Generate the gradient and Laplacian operators.

Orthogonalize EOF modes.

Compute a preconditioner using a modified incomplete Cholesky decomposition.

No preconditioner is used.

Compute a preconditioner using the Cholesky decomposition.

A realistic example of divand in 2 dimensions with salinity observations in the Mediterranean Sea at 30m.

The RMS error between two variables.

A simple example of divand in 2 dimensions with observations from an analytical function.

Solve the variational problem.

Solve the variational problem with the contraints from EOFs.

Interpolation matrix for a n-dimensional interpolation.

Derive fractional indices on a regular grid.

Derive fractional indices on a separable grid.

Product between a Gaussian covariance matrix and a vector.

Create diagonal sparse matrix.

Sparse operator for differentiation.

Sparse operator for a gradient.

Create a sparse interpolation matrix.

Create a sparse matrix which packs an array under the control of a mask.

Sparse operator shifting a field in a given dimension.

Sparse operator for staggering.

Sparse operator for trimming.

Initialize structure for packing and unpacking given their mask.

Pack a series of variables into a vector under the control of a mask.

Unpack a vector into different variables under the control of a mask.

Testing divand in 1 dimension.

Testing divand in 2 dimensions.

Testing divand in 2 dimensions with advection.

Testing divand in 2 dimensions with independent verification.

Testing divand in 2 dimensions with correlated errors.

Testing divand in 2 dimensions with a custom constrain.

Testing divand in 2 dimensions in a cyclic domain.

Testing divand in 2 dimensions with EOF constraints.

Testing divand in 2 dimensions with lenx /= leny.

Testing divand in 2 dimensions with pcg solver.

Testing divand in 2 dimensions with relative correlation length.

Testing divand in 3 dimensions.

Testing divand in 3 dimensions without correlation in the 3rd dimension (vertically stacked).

Testing divand in 4 dimensions.

Test if divand is working correctly.

Testing 1D linear interpolation.

Testing 2D linear interpolation.

Testing linear interpolation on regular grid.

Testing sparse operators.

Run examples embedded in documentation.

Computes Delta method mean and covariance of a nonlinear transformation defined by "func"

usage: [theta, obj_value, convergence, iters] = gmm_estimate(theta, data, weight, moments, momentargs, control, nslaves)

GMM example file, shows initial consistent estimator, estimation of efficient weight, and second round efficient estimator

The GMM objective function, for internal use by gmm_estimate This is scaled so that it converges to a finite number.

usage: [theta, V, obj_value] = gmm_results(theta, data, weight, moments, momentargs, names, title, unscale, control, nslaves)

GMM variance, which assumes weights are optimal

GMM variance, which assumes weights are not optimal

kernel_density: multivariate kernel density estimator

cvscore = kernel_density_cvscore(bandwidth, data, kernel)

kernel_example: examples of how to use kernel density and regression functions requires the optim and plot packages from Octave Forge

kernel_optimal_bandwidth: find optimal bandwith doing leave-one-out cross validation inputs: * data: data matrix * depvar: column vector or empty ("").

kernel_regression: kernel regression estimator

cvscore = kernel_regression_cvscore(bandwidth, data, depvar)

usage: [theta, obj_value, conv, iters] = mle_estimate(theta, data, model, modelargs, control, nslaves)

Example to show how to use MLE functions

usage: [obj_value, score] = mle_obj(theta, data, model, modelargs, nslaves)

contrib = mle_obj_nodes(theta, data, model, modelargs, nn)

usage: [theta, V, obj_value, infocrit] = mle_results(theta, data, model, modelargs, names, title, unscale, control)

usage: [theta, obj_value, conv, iters] = nls_estimate(theta, data, model, modelargs, control, nslaves)

define arguments for nls_estimate #

usage: [obj_value, score] = nls_obj(theta, data, model, modelargs, nslaves)

usage: theta = parameterize(theta, otherargs) This is an empty function, provided so that delta_method will work as is.

Example likelihood function (Poisson for count data) with score

the form a user-written moment function should take

this prints matrices with row and column labels

this prints matrices with column labels but no row labels

Standardizes and normalizes data matrix, primarily for use by BFGS

Unscales parameters that were estimated using scaled data primarily for use by BFGS

Construct a BilinearForm previously imported from ufl.

Creates a constant object over all the mesh elements with the value specified.

Specify essential boundary condition on a specific side.

Creates an object with the value specified as a function handle.

Initialize an object with the values specified in a vector or extracting a component from a vectorial field.

Generate a FunctionSpace on a specific mesh.

Construct a Functional previously imported from a ufl file.

Construct a JacobianForm previously imported from a ufl file with the function import_ufl_BilinearForm.

Construct a Functional previously imported from a ufl file.

Construct a mesh from file or from (p, e, t) format.

Initialize a MeshFunction with the values contained in a file.

Construct a ResidualForm previously imported from a ufl file with the function import_ufl_LinearForm.

Initialize a SubDomain with a function handle, INSIDE, and a binary flag.

Construct the discretization of a Form and apply essential BC.

Construct the discretization of a system and apply essential BC.

Set an MPI barrier.

Compile a wrapper for dolfin::MeshFunction

Import a BilinearForm from a ufl file.

Import a FunctionSpace from a ufl file.

Import a Functional from a ufl file.

Import a LinearForm from a ufl file.

Import a Variational Problem from a ufl file.

Interpolate a function on a FunctionSpace.

Return true if called on node zero.

Query or set the internal variable that specifies the linear algebra back-end to use when assembling systems, matrices or vectors.

Mark MESHFUNCTION with NUMBER on the entities contained in SUBDOMAIN.

Writes the given line to a ufl file.

Compute American call and put option prices using a binomial tree.

Compute implied volatility under the Black-Scholes model.

Compute European call and put option price using the Black-76 model.

Computes the Black-Scholes delta, the rate of change of the option value with respect to the value of the underlying asset.

Compute Black-Scholes gamma.

Computes implied volatility under the Black-Scholes model.

Computes elasticity of option under the Black-Scholes model.

Compute European call and put option prices.

Compute the Black-Scholes rho.

Compute the Black-Scholes theta.

Computes the Black-Scholes vega.

Creates an object to represent an arithmetic Brownian motion.

If no output is requested, plot the bollinger bands of the ASSET.

Return the datenum of the next or previous business day from REFDATE.

Generate a list of business dates at the end of the periods defined between (including) SDATE and EDATE.

Creates an object to represent a constant elasticity of variance (CEV) stochastic differential equation (SDE).

Calculate convexity CFCONV from given fixed-paid cash flow CF and period yield YIELD.

Calculate duration DUR and modified duration MOD_DUR, from given fixed-paid cash flow CF and period yield YIELD.

Creates an object to represent a Cox-Ingersoll-Ross (CIR) mean-reverting square root diffusion.

Convert standard deviation SIGMA and correlation coefficients CORR to covariance COV.

Convert covariance COV from input to standard deviation SIGMA and correlation coefficients CORR.

Convert the current axis tick labels (or the axis handle H) to a date format.

Find any instances of the 'subset' in the 'superset' with the 'tol'erance.

Return hours of a date.

Calculates the number of days between two dates.

Return the month (M) and day (D) of Easter in the Gregorial calendar on a given year or years.

Compute the effective rate of return based on a nominal RATE over a number of periods, NUMPERIODS.

Return the last day of the month M for the year Y in datenum format.

Return the datenum of the first business day of the YEAR and MONTH.

Download stock data from a connection.

Return the future value at the end of period N of an investment which consists of N payments of P in each period, assuming an interest rate R.

Return the future value at the end of N periods of an initial lump sum investment L, given a per-period interest rate R.

Creates an object to represent a geometric Brownian motion (GBM).

Prepare a Google connection for the fetch command to get Google historical quote data.

Creates an object to represent a Heston stochastic volatility model.

Compute the highest high value of DATA for the past NPERIODS (default: 14) across the dimension, DIM (default: 1).

Plot the HIGH, LOW, and CLOSE of a security.

List holidays and non-trading days.

Return hours of a date.

Creates an object to represent a Hull-White/Vasicek (HWV) diffusion.

Return the internal rate of return of a series of payments P from an initial investment I (i.e., the solution of 'npv (r, p) = i'.

Return true if the REFDATE is a business date REFDATE.

Return the datenum of the last business day of the YEAR and MONTH.

Compute the lowest low value of DATA for the past NPERIODS (default: 14) across the dimension, DIM (default: 1).

Returns the last occurrence of WEEKDAY from the MONTH and YEAR.

Convert DATENUMS from the internal date format to the format used by Microsoft Excel.

Calculate the Moving Average Convergence/Divergence (MACD) line of an asset from the vector of prices (DATA).

Return minutes of a date.

Compute the modified internal rate of return.

Return month of a date.

Return the number of whole months between STARTDATE and ENDDATE.

Calculate the LEADing and LAGging moving average of an ASSET.

Compute the negative volume index of a security based on its closing price (CLOSEPRICE) and VOLume.

Compute the nominal rate of return based on a effective RATE over a number of periods, NUMPERIODS.

Return the number of regular payments of P necessary to amortize A loan of amount A and interest R.

Net present value of a series of payments.

Returns the Nth occurrence of WEEKDAY from the MONTH and YEAR.

Compute the on balance volume of a security based on its closing price (CLOSEPRICE) and VOLume.

Compute profit of an option.

Return the amount of periodic payment necessary to amortize a loan of amount a with interest rate R in N periods.

Plot the point figure chart of an ASSET.

Compute the positive volume index of a security based on its closing price (CLOSEPRICE) and VOLume.

Returns the present value of an investment that will pay off P for N consecutive periods, assuming an interest R.

Return the present value V of an investment that will pay off P in one lump sum at the end of N periods, given the interest rate R.

Return the rate of return R on an investment of present value V which pays P in N consecutive periods.

Plots price changes using a Renko chart.

Compute the relative strength index (RSI) of an asset from the vector of closing prices (CLOSEPRICE).

Creates an object to represent a stochastic differential equation (SDE) using drift and diffusion objects.

Creates an object to represent a stochastic differential equation (SDE) in linear drift-rate form.

Creates an object to represent a stochastic differential equation (SDE) in in mean-reverting drift-rate form.

Return seconds of a date.

Compute the taxed rate of RETURN based on a PRETAXRETURN rate and a TAXRATE.

Find the third Wednesday of the month specified by the MONTH and YEAR.

Returns the current local date as the number of days since Jan 1, 0000.

Return the volatility VOLAT of each column of the input matrix X.

Return the week number of the year of a date

Convert DATENUMS from the Microsoft Excel date format to the format used by 'datenum'.

Prepare a Yahoo connection for the fetch command to get Yahoo historical quote data.

Return year of a date.

Return the number of days in the year Y with an optional basis B.

Read FITS file FILENAME and return image data in IMAGE, and the image header in HEADER.

Write IMAGE to FITS file FILENAME.

Write IMAGE to FITS file FILENAME.

Assemble a ParaView collection file (pvd) from a set of files representing data at different time-steps.

Output data field in binary serial XML-VTK UnstructuredGrid format.

Output data field in binary serial XML-VTK UnstructuredGrid format.

Output data field in serial XML-VTK UnstructuredGrid format.

Plot a triangular mesh in 3D given a mesh structure and node data.

Plot a 3D surface given node or element data on a triangular mesh.

Save a 3-D scalar array ARRAY to the file FILENAME in VTK structured-grid format.

Save a 3-D vector field of components X, Y, Z to the file FILENAME in VTK format.

Add a membership function to an existing FIS structure and return the updated FIS.

Add a list of rules to an existing FIS structure and return the updated FIS.

Add an input or output variable to an existing FIS structure and return the updated FIS.

Return the algebraic product of the input.

Return the algebraic sum of the input.

Return the bounded difference of the input.

Return the bounded sum of the input.

Demonstrate the use of the Octave Fuzzy Logic Toolkit to approximate a non-linear function using a Sugeno-type FIS with linear output functions.

For a given domain, set of fuzzy function values, and defuzzification method, return the defuzzified (crisp) value of the fuzzy function.

Return the drastic product of the input.

Return the drastic sum of the input.

For a given domain X and parameters PARAMS (or [A1 C1 A2 C2]), return the corresponding Y values for the difference between two sigmoidal membership functions.

Return the Einstein product of the input.

Return the Einstein sum of the input.

Return the crisp output(s) of an FIS for each row in a matrix of crisp input values.

For a given domain, set of parameters, membership function type, and optional hedge and not_flag, return the corresponding y-values for the membership function.

Using the Fuzzy C-Means algorithm, calculate and return the soft partition of a set of unlabeled data points.

For a given domain X and parameters PARAMS (or [SIG1 C1 SIG2 C2]), return the corresponding Y values for the two-sided Gaussian composite membership function.

For a given domain X and parameters PARAMS (or [SIG C]), return the corresponding Y values for the Gaussian membership function.

For a given domain X and parameters PARAMS (or [A B C]), return the corresponding Y values for the generalized bell-shaped membership function.

Generate and plot a surface (or 2-dimensional curve) showing one FIS output as a function of two (or one) of the FIS inputs.

Return or print the property (field) values of an FIS structure specified by the arguments.

Using the Gustafson-Kessel algorithm, calculate and return the soft partition of a set of unlabeled data points.

Return the Hamacher product of the input.

Return the Hamacher sum of the input.

Demonstrate the use of newfis, addvar, addmf, addrule, and evalfis to build and evaluate an FIS.

Demonstrate the use of the Octave Fuzzy Logic Toolkit to read and evaluate a Sugeno-type FIS stored in a file.

Demonstrate the use of the Octave Fuzzy Logic Toolkit to read and evaluate a Mamdani-type FIS stored in a file.

Demonstrate the use of linear output membership functions to simulate constant membership functions.

Demonstrate the use of the Octave Fuzzy Logic Toolkit to read and evaluate a Mamdani-type FIS stored in a file.

Create and return a new FIS structure using the argument values provided.

Return the partition coefficient for a given soft partition.

Return the partition entropy for a given soft partition.

For a given domain X and parameters PARAMS (or [A B C D]), return the corresponding Y values for the pi-shaped membership function.

Plot the membership functions defined for the specified FIS input or output variable on a single set of axes.

For a given domain X and parameters PARAMS (or [A1 C1 A2 C2]), return the corresponding Y values for the product of two sigmoidal membership functions.

Read the information in an FIS file, and using this information, create and return an FIS structure.

Remove a membership function from an existing FIS structure and return the updated FIS.

Remove an input or output variable from an existing FIS structure and return the updated FIS.

Set a property (field) value of an FIS structure and return the updated FIS.

Print all of the property (field) values of the FIS structure and its substructures.

Show the rules for an FIS structure in verbose, symbolic, or indexed format.

For a given domain X and parameters PARAMS (or [A C]), return the corresponding Y values for the sigmoidal membership function.

For a given domain X and parameters PARAMS (or [A B]), return the corresponding Y values for the S-shaped membership function.

Demonstrate the use of the Octave Fuzzy Logic Toolkit to read and evaluate a Sugeno-type FIS with multiple outputs stored in a text file.

For a given domain X and parameters PARAMS (or [A B C D]), return the corresponding Y values for the trapezoidal membership function.

For a given domain X and parameters PARAMS (or [A B C]), return the corresponding Y values for the triangular membership function.

Save the specified FIS currently in the Octave workspace to a file named by the user.

Return the Xie-Beni validity index for a given soft partition.

For a given domain X and parameters PARAMS (or [A B]), return the corresponding Y values for the Z-shaped membership function.

simplified example (nvars == 4) p1 = [varA varB varC varD] p2 = [var1 var2 var3 var4] b = [1 1 0 1] child = [varA varB var3 varD]

TODO ranks ([7,2,2]) == [3.0,1.5,1.5] is [3,1,2] (or [3,2,1]) useful?

Find minimum of function using genetic algorithm.

Create a random initial population with a uniform distribution.

Create genetic algorithm options structure.

start mutationgaussian logic

Rastrigin's function.

fix an entry of the steps (or parents) vector

Execute all available tests at once.

hash = SHA1 (...) SHA1 implements the Secure Hash Algorithm Cryptographic Hashing (One-Way) function.

Perform an adaptive resampling of a planar curve.

MAJLE (Weak) Majorization check
S = MAJLE(X,Y) checks if the real part of X is (weakly) majorized by
the real part of Y, where X and Y must be numeric (full or sparse)
arrays.

mark_for_deletion ( filename1, filename2, ...

Create struct from variables.

This function forms product(s) of elements of the array X along the dimension specified by DIM, analogically to 'prod', but avoids overflows and underflows if possible.

Create a table out of the input arguments, if possible.

Create variables from fields of a struct.

Perform a uniform resampling of a planar curve.

Performs the reverse of 'vech' on the vector V.

Replaces tiny elements of the vector X by zeros.

Query Octave Forge website to check for duplicate symbols.

Generate HTML documentation for the core functions provided by Octave.

Generate a HTML page with a list of operators available in GNU Octave.

Generate HTML documentation for a package.

Returns a structure containing design options for various project web sites.

Writes a function help text to disk formatted as HTML.

Converts texinfo function help to a html page.

Convert '.txi' files in the Octave source into an INDEX structure suitable for generating a functon reference.

Convert '.txi' files in the Octave source into a functon reference.

Asynchroneously view an url.

Compute horizontal angle between 2 points

Computes the angle between the points P1, P2 and P3.

Computes the absolute angular difference between two angles in radians.

Difference between two angles

Compute angle between three 3D points

Sort points in the plane according to their angle to origin

Sort 3D coplanar points according to their angles in plane

Description of functions for manipulating angles

ANGLES3D Conventions for manipulating angles in 3D

Finds the four lines tangent to two circles with given centers and radii.

Return the bisector of two lines, or 3 points.

BOUNDEDVORONOI2D Return a bounded voronoi diagram as a graph structure

Bounding box of a set of 3D points

Volume of a 3-dimensional box

BOXTOMESH Convert a box into a quad mesh with the same size

Description of functions operating on bounding boxes.

BOXES3D Description of functions operating on 3D boxes

Convert cartesian to cylindrical coordinates

Convert cartesian coordinates to spherical coordinates

Convert cartesian coordinates to spherical coordinates in degrees

Create a straight line from cartesian equation coefficients.

Returns the polynomial representation of the cubic Bezier defined by the control points POINTS.

Compute centroid (center of mass) of a set of points.

CENTROIDALVORONOI2D Centroidal Voronoi tesselation within a polygon

CHECKMESHADJACENTFACES Check if adjacent faces of a mesh have similar orientation

Return the first point of a 3D circle

Coordinates of a point on a 3D circle from its position

Return the angular position of a point on a 3D circle

Convert a circle arc into a series of points

Convert a circle into a series of points

Description of functions operating on circles

CIRCLES3D Description of functions operating on 3D circles

CLIPCONVEXPOLYHEDRONHP Clip a convex polyhedron by a plane

Clip an edge with a rectangular box.

CLIPGRAPH Clip a graph with a rectangular area

CLIPGRAPHPOLYGON Clip a graph with a polygon

Clip a line with a box.

CLIPLINE3D Clip a line with a box and return an edge

CLIPMESHVERTICES Clip vertices of a surfacic mesh and remove outer faces

Clip a set of points by a box.

Perform boolean operation on polygon(s) using one of boolean methods.

Perform boolean operation on polygon(s) using one of boolean methods.

Clip (possibly composite) polylines with polygon(s) using one of boolean methods.

Clip (possibly composite) polylines with polygon(s) using one of boolean methods.

Clip a ray with a box.

Returns a simple closed path that passes through all the points in X.

CONVEXHULL Convex hull of a set of points

Calculates ellipse parameters from covariance matrix.

Create a (bounded) crack pattern tessellation

Create a (bounded) crack pattern tessellation

Compute matrix for transforming a basis into another basis

Create a circle from 2 or 3 points.

Create a 3D mesh representing the unit cube

Create a 3D mesh representing a cube-octahedron

Create a circle from 2 or 3 points.

CREATEDODECAHEDRON Create a 3D mesh representing a dodecahedron

CREATEDURERPOLYHEDRON Create a mesh representing Durer's polyhedron

Create an edge between two points, or from a line.

Create the the 3x3 matrix of an homothetic transform.

CREATEICOSAHEDRON Create a 3D mesh representing an Icosahedron.

Create a straight line from 2 points, or from other inputs

Create the the 3x3 matrix of a line reflection.

CREATEMENGERSPONGE Create a cube with an inside cross removed

CREATEOCTAHEDRON Create a 3D mesh representing an octahedron

Create a plane in parametrized form

Create a ray (half-line), from various inputs.

CREATERHOMBODODECAHEDRON Create a 3D mesh representing a rhombododecahedron

Create the 3*3 matrix of a rotation.

CREATEROTATION3DLINEANGLE Create rotation around a line by an angle theta

Create the 4x4 matrix of a 3D rotation around x-axis

Create the 4x4 matrix of a 3D rotation around x-axis

Create the 4x4 matrix of a 3D rotation around x-axis

Create the 3x3 matrix of a scaling in 2 dimensions.

Create the 4x4 matrix of a 3D scaling

CREATESOCCERBALL Create a 3D mesh representing a soccer ball

CREATETETRAHEDRON Create a 3D mesh representing a tetrahedron

CREATETETRAKAIDECAHEDRON Create a 3D mesh representing a tetrakaidecahedron

Create the 3*3 matrix of a translation.

Create the 4x4 matrix of a 3D translation

Create a vector from two points.

Estimate curvature of a polyline defined by points.

Adaptive sampling of a parametric curve.

Evaluates parametric CURVE at T.

CVTUPDATE Update germs of a CVT with given points

Convert cylindrical to cartesian coordinates

CYLINDERMESH Create a 3D mesh representing a cylinder

Uses data to build a file compatible with Gmsh.

Graph associated to Delaunay triangulation of input points

Minimum distance between a point and an edge

Minimum distance between a point and a line

Euclidean distance between 3D point and line

Compute shortest distance between a point and a polygon

Compute shortest distance DIST between a point and a polyline

Compute euclidean distance between pairs of points in any dimension

Compute the shortest distance between 2 polygons

Draw an arrow on the current axis.

Draw a coordinate system and an origin

Draw a cubic bezier curve defined by the control points POINTS.

Draw a box defined by coordinate extents

Draw a 3D box defined by coordinate extents

Draw an edge centered on a point.

Draw a circle on the current axis

Draw a 3D circle

Draw a circle arc on the current axis

Draw a 3D circle arc

Draw a 3D centered cube, eventually rotated

Draw a cylinder

Draw an edge given by 2 points.

Draw 3D edge in the current Window

Draw an ellipse on the current axis.

Draw an ellipse arc on the current axis.

DRAWFACENORMALS Draw normal vector of each face in a mesh

Draw a graph, given as a set of vertices and edges

DRAWGRAPHEDGES Draw edges of a graph

Draw labels at specified positions.

Draw the line on the current axis.

DRAWLINE3D Draw a 3D line on the current axis

Draw a 3D mesh defined by vertices and faces

DRAWNODELABELS Draw values associated to graph nodes Usage: drawNodeLabels(NODES, VALUES); NODES: array of double, containing x and y values of nodes VALUES is an array the same length o

Draw centered oriented rectangle.

Draw a parabola on the current axis.

DRAWPLANE3D Draw a plane clipped in the current window

Draw the point on the axis.

Draw 3D point on the current axis.

Draw a polygon specified by a list of points.

Draw a 3D polygon specified by a list of vertices

DRAWPOLYHEDRON Draw polyhedron defined by vertices and faces

DRAWPOLYLINE Draw a polyline specified by a list of points

Draw a 3D polyline specified by a list of vertices

Draw a polynomial curve approximation

Draw a ray on the current axis.

Draw rectangle on the current axis.

Draw various types of shapes (circles, polygons...).

Draw a sphere as a mesh

Draw an edge on the surface of a sphere

Draw a spherical polygon

Draw a triangle on a sphere

Draw a torus (3D ring)

Draw vector at a given position

Return angle of edge

Return length of an edge

Return position of a point on an edge

Convert an edge to a straight line

Description of functions operating on planar edges

Calculates covariance matrix from ellipse.

Convert an ellipse into a series of points

Description of functions operating on ellipses.

ELLIPSOIDMESH Convert a 3D ellipsoid to face-vertex mesh representation

Find the minimum circle enclosing a set of points.

EULERANGLESTOROTATION3D Convert 3D Euler angles to 3D rotation matrix

Expand a polygon by a given (signed) distance

FACECENTROIDS Compute centroids of a mesh faces

FACENORMAL Compute normal vector of faces in a 3D mesh

Fill a polygon specified by a list of points

Find index of closest point in an array and the distance between POINT and closest point in POINTARRAY.

Fit an affine transform using two point sets.

Geometry 2D Toolbox Version 1.2.0 21-Oct-2011 .

GEOM3D Geometry 3D Toolbox Version 1.0 21-Mar-2011 .

GRADJACENTEDGES Find list of edges adjacent to a given node

GRADJACENTNODES Find list of nodes adjacent to a given node

GREDGELENGTHS Compute length of edges in a geometric graph

GRSHORTESTPATH Find a shortest path between two nodes in the graph

GRAPHS Simple Toolbox for manipulating Geometric Graphs Version 0.5 11-Apr-2010 .

Generate hexagonal grid of points in the plane.

Inertia ellipse of a set of points

Intersection of two bounding boxes.

Intersection points of two circles.

INTERSECTEDGEPOLYGON Intersection point of an edge with a polygon

Return all intersections between two set of edges

Intersection point(s) of a line and a circle

Return intersection between a line and an edge.

INTERSECTLINEMESH3D Intersection points of a 3D line with a mesh

Intersection point between a 3D line and a plane

INTERSECTLINEPOLYGON Intersection points between a line and a polygon

INTERSECTLINESPHERE Return intersection points between a line and a sphere

Return all intersection points of N lines in 2D.

INTERSECTPLANEMESH Compute the polygons resulting from plane-mesh intersection

Return intersection circle between a plane and a sphere

INTERSECTPOLYLINES Find the common points between 2 polylines

ISAXISHANDLE Check if the input corresponds to a valid axis hanfle

Compute relative orientation of 3 points

Test if a point is on the left side of a line

Check parallelism of two vectors

heck orthogonality of two vectors.

Test if a point is located inside a given circle

Check if a point is located inside a given ellipse

ISPOINTINPOLYGON Test if a point is located inside a polygon

Test if a point is located on a given circle.

Test if a point belongs to an edge.

Test if a point belongs to a line

Test if a point belongs to a ray

Returns true if the polygon P are oriented Counter-Clockwise.

Inspect winding direction of polygon(s).

Convert a cell style set of polygons into an array of subpolygons separated by NaN rows.

Create the k-nearest neighbors graph of a set of points

Computes angle between two straight lines

Position of a point on a line.

LINEPOSITION3D Return the position of a 3D point projected on a 3D line

Description of functions operating on planar lines.

LINES3D Description of functions operating on 3D lines

Compute medial axis of a convex polygon

Create a median line between two points.

Merge two boxes, by computing their greatest extent.

MERGECOPLANARFACES Merge coplanar faces of a polyhedral mesh

MESHADJACENCYMATRIX Compute adjacency matrix of a mesh from set of faces

MESHDIHEDRALANGLES Dihedral at edges of a polyhedal mesh

ok

ok

MESHEDGES Computes array of edge vertex indices from face array

MESHFACE Return the vertex indices of a face in a mesh

MESHFACEADJACENCY Compute adjacency list of face around each face

MESHFACEEDGES Computes edge indices of each face

MESHFACENUMBER Returns the number of faces in this mesh

MESHFACEPOLYGONS Returns the set of polygons that constitutes a mesh

MESHSURFACEAREA Surface area of a polyhedral mesh

MESHVOLUME Volume of the space enclosed by a polygonal mesh

MESHES3D 3D Surface Meshes Version 1.0 21-Mar-2011 .

Middle point of two points or of an edge

MINCONVEXHULL Return the unique minimal convex hull of a set of 3D points

Minimal distance between several points.

MINIMUMCALIPERDIAMETER Minimum caliper diameter of a set of points

NNDIST Nearest-neighbor distances of each point in a set

Normalize an angle value within a 2*PI interval

Normalize parametric representation of a plane

Normalize a vector to have norm equal to 1

Orient polygon counterclockwise or clockwise.

Create a line orthogonal to another one.

Create a line parallel to another one.

Parametrization of a curve, based on edges length

Compute the normal to a plane

PLANEPOINT Compute 3D position of a point in a plane

Compute position of a point on a plane

PLANES3D Description of functions operating on 3D planes

Pots a 2D shape defined by piecewise smooth polynomials in the current axis.

Create a point on a line at a given position on the line.

Description of functions operating on points.

POINTS3D Description of functions operating on 3D points

Create a point from polar coordinates (rho + theta)

Connect outer (filled) polygon and inner (hole) polygons using branch cuts such that all polygons are connected as one string of vertices, for subsequent plotting polygons with holes using the functio

Converts a polygon to a shape with edges defined by smooth polynomials.

Compute the signed area of a polygon.

Area of a 3D polygon

POLYGONBOUNDS Compute the bounding box of a polygon

Compute the centroid (center of mass) of a polygon.

POLYGONCONTAINS Test if a point is contained in a multiply connected polygon

Divide a possibly self-intersecting polygon into a set of simple loops

Extract a point from a polygon

Find-self intersection points of a polygon

Extract a portion of a polygon

Description of functions operating on 2D polygons

POLYGONS3D Description of functions operating on 3D polygons

POLYHEDRA Index of classical polyhedral meshes Polyhedra are specific meshes, with additional assumptions: * the set of faces is assumed to enclose a single 3D domain * each face has a ne

ok

POLYHEDRONMEANBREADTH Mean breadth of a convex polyhedron

POLYHEDRONNORMALANGLE Compute normal angle at a vertex of a 3D polyhedron

POLYHEDRONSLICE Intersect a convex polyhedron with a plane.

Find self-intersections points of a polyline

Compute the centroid of a polynomial curve

Compute derivative vector of a polynomial curve

Fit a polynomial curve to a series of points

Compute point corresponding to a position

Fit a set of polynomial curves to a segmented image

Project of a point orthogonally onto a line

Return the orthogonal projection of a point on a plane

Compute the position of the orthogonal projection of a point on a polyline.

Compute the radical axis (or radical line) of 2 circles

Generate random points within a box.

Description of functions operating on planar rays

READMESH_OFF Read mesh data stord in OFF format

RECENTERTRANSFORM3D Change the fixed point of an affine 3D transform

Convert a (centered) rectangle into a series of points

REMOVEMESHVERTICES Remove vertices and associated faces from a mesh

Intervert the source and target vertices of edge

Return same line but with opposite orientation

Reverse a polygon, by iterating vertices from the end

Reverse a polyline, by iterating vertices from the end

Create a surface of revolution from a planar curve

Rotate a vector by a given angle

ROTATION3DAXISANDANGLE Determine axis and angle of a 3D rotation matrix

Transforms a 2D shape described by piecewise smooth polynomials into a polygon.

Centroid of a simple plane shape defined with piecewise smooth polynomials.

Simplify a polygon using the Ramer-Douglas-Peucker algorithm.

Simplify or subsample a polyline using the Ramer-Douglas-Peucker algorithm, a.k.a.

SMOOTHMESH Smooth mesh by replacing each vertex by the average of its neighbors

Convert spherical coordinates to cartesian coordinates

Convert spherical coordinates to cartesian coordinates in degrees

SPHEREMESH Create a 3D mesh representing a sphere

Description of functions operating on 3D spheres

Convert a NaN separated polygon list to a cell array of polygons.

Generate equally spaces points in plane.

STEINERPOLYTOPE Create a steiner polytope from a set of vectors

SUBDIVIDEMESH Subdivides each face of the mesh

Compute support function of a polygon

SURFTOMESH Convert surface grids into face-vertex mesh

TETRAHEDRONVOLUME Signed volume of a tetrahedron

TORUSMESH Create a 3D mesh representing a torus

Transform an edge with an affine transform.

Transform a line with an affine transform.

TRANSFORMLINE3D Transform a 3D line with a 3D affine transform

Transform a point with an affine transform.

Transform a point with a 3D affine transform

Applies transformation to a shape defined by piecewise smooth polynomials.

Transform a vector with an affine transform

TRANSFORMVECTOR3D Transform a vector with a 3D affine transform

Description of functions operating on transforms

Generate triangular grid of points in the plane.

TRIANGULATEFACES Convert face array to an array of triangular faces

TRIMMESH Reduce memory footprint of a polygonal mesh

TRIMESHEDGEFACES Compute index of faces adjacent to each edge of a triangular mesh

TRIMESHMEANBREADTH Mean breadth of a triangular mesh

TRIMESHSURFACEAREA Surface area of a triangular mesh

Angle of a vector, or between 2 vectors

Angle between two 3D vectors

Compute norm of a vector, or of a set of vectors

Description of functions operating on plane vectors

VECTORS3D Description of functions operating on 3D vectors

VERTEXNORMAL Compute normals to a mesh vertices

Compute a voronoi diagram as a graph structure

gsl_sf is an oct-file containing Octave bindings to the special functions of the GNU Scientific Library (GSL).

Computes the integral

Computes the Cosine integral Ci(x) = -\int_x^\infty dt \cos(t)/t for x > 0.

Computes the integral Shi(x) = \int_0^x dt \sinh(t)/t.

Computes the Sine integral Si(x) = \int_0^x dt \sin(t)/t.

Computes the Airy function Ai(x) with an accuracy specified by mode.

Computes the Airy function derivative Ai'(x) with an accuracy specified by mode.

Computes the derivative of the scaled Airy function S_A(x) Ai(x).

Computes a scaled version of the Airy function S_A(x) Ai(x).

Computes the Airy function Bi(x) with an accuracy specified by mode.

Computes the Airy function derivative Bi'(x) with an accuracy specified by mode.

Computes the derivative of the scaled Airy function S_B(x) Bi(x).

Computes a scaled version of the Airy function S_B(x) Bi(x).

Computes the location of the s-th zero of the Airy function Ai(x).

Computes the location of the s-th zero of the Airy function derivative Ai(x).

Computes the location of the s-th zero of the Airy function Bi(x).

Computes the location of the s-th zero of the Airy function derivative Bi(x).

Computes the Arctangent integral AtanInt(x) = \int_0^x dt \arctan(t)/t.

Computes the regular modified cylindrical Bessel function of order n, I_n(x).

his routine computes the values of the regular modified cylindrical Bessel functions I_n(x) for n from nmin to nmax inclusive.

Computes the scaled regular modified cylindrical Bessel function of order n, \exp(-|x|) I_n(x)

This routine computes the values of the scaled regular cylindrical Bessel functions \exp(-|x|) I_n(x) for n from nmin to nmax inclusive.

Computes the regular modified Bessel function of fractional order nu, I_\nu(x) for x>0, \nu>0.

Computes the scaled regular modified Bessel function of fractional order nu, \exp(-|x|)I_\nu(x) for x>0, \nu>0.

Computes the regular cylindrical Bessel function of order n, J_n(x).

This routine computes the values of the regular cylindrical Bessel functions J_n(x) for n from nmin to nmax inclusive.

Computes the regular cylindrical Bessel function of fractional order nu, J_\nu(x).

Computes the irregular modified cylindrical Bessel function of order n, K_n(x), for x > 0.

This routine computes the values of the irregular modified cylindrical Bessel functions K_n(x) for n from nmin to nmax inclusive.

ERR contains an estimate of the absolute error in the value Z.

This routine computes the values of the scaled irregular cylindrical Bessel functions \exp(x) K_n(x) for n from nmin to nmax inclusive.

Computes the irregular modified Bessel function of fractional order nu, K_\nu(x) for x>0, \nu>0.

Computes the scaled irregular modified Bessel function of fractional order nu, \exp(+|x|) K_\nu(x) for x>0, \nu>0.

Computes the irregular cylindrical Bessel function of order n, Y_n(x), for x>0.

This routine computes the values of the irregular cylindrical Bessel functions Y_n(x) for n from nmin to nmax inclusive.

Computes the irregular cylindrical Bessel function of fractional order nu, Y_\nu(x).

Computes the scaled regular modified spherical Bessel function of order l, \exp(-|x|) i_l(x)

This routine computes the values of the scaled regular modified spherical Bessel functions \exp(-|x|) i_l(x) for l from 0 to lmax inclusive for lmax >= 0.

Computes the regular spherical Bessel function of order l, j_l(x), for l >= 0 and x >= 0.

Computes the values of the regular spherical Bessel functions j_l(x) for l from 0 to lmax inclusive for lmax >= 0 and x >= 0.

This routine uses Steedâ€™s method to compute the values of the regular spherical Bessel functions j_l(x) for l from 0 to lmax inclusive for lmax >= 0 and x >= 0.

Computes the scaled irregular modified spherical Bessel function of order l, \exp(x) k_l(x), for x>0.

This routine computes the values of the scaled irregular modified spherical Bessel functions \exp(x) k_l(x) for l from 0 to lmax inclusive for lmax >= 0 and x>0.

Computes the logarithm of the irregular modified Bessel function of fractional order nu, \ln(K_\nu(x)) for x>0, \nu>0.

Computes the irregular spherical Bessel function of order l, y_l(x), for l >= 0.

This routine computes the values of the irregular spherical Bessel functions y_l(x) for l from 0 to lmax inclusive for lmax >= 0.

Computes the location of the s-th positive zero of the Bessel function J_0(x).

Computes the location of the s-th positive zero of the Bessel function J_1(x).

Computes the location of the n-th positive zero of the Bessel function J_x().

Computes the Beta Function, B(a,b) = \Gamma(a)\Gamma(b)/\Gamma(a+b) for a > 0, b > 0.

Computes the normalized incomplete Beta function

Computes the combinatorial factor n choose m = n!/(m!(n-m)!).

The Clausen function is defined by the following integral,

Computes the conical function P^0_{-1/2 + i \lambda}(x) for x > -1.

Computes the conical function P^1_{-1/2 + i \lambda}(x) for x > -1.

Computes the Regular Cylindrical Conical Function P^{-m}_{-1/2 + i \lambda}(x), for x > -1, m >= -1.

Computes the irregular Spherical Conical Function P^{1/2}_{-1/2 + i \lambda}(x) for x > -1.

Computes the regular Spherical Conical Function P^{-1/2}_{-1/2 + i \lambda}(x) for x > -1.

Computes the Regular Spherical Conical Function P^{-1/2-l}_{-1/2 + i \lambda}(x), for x > -1, l >= -1.

computes the Wigner 3-j coefficient,

computes the Wigner 6-j coefficient,

computes the Wigner 9-j coefficient,

The Dawson integral is defined by \exp(-x^2) \int_0^x dt \exp(t^2).

The Debye functions are defined by the integral

The Debye functions are defined by the integral

The Debye functions are defined by the integral

The Debye functions are defined by the integral

The Debye functions are defined by the integral

The Debye functions are defined by the integral

Computes the dilogarithm for a real argument.

Compute the double factorial n!! = n(n-2)(n-4)\dots.

This function computes the incomplete elliptic integral D(\phi,k) which is defined through the Carlson form RD(x,y,z) by the following relation,

This routine computes the elliptic integral E(\phi,k) to the accuracy specified by the mode variable mode.

Computes the complete elliptic integral E(k) to the accuracy specified by the mode variable mode.

This routine computes the elliptic integral F(\phi,k) to the accuracy specified by the mode variable mode.

Computes the complete elliptic integral K(k) pi --- 2 /

This routine computes the incomplete elliptic integral \Pi(\phi,k,n) to the accuracy specified by the mode variable mode.

Computes the complete elliptic integral \Pi(k,n) to the accuracy specified by the mode variable mode.

This routine computes the incomplete elliptic integral RC(x,y) to the accuracy specified by the mode variable mode.

This routine computes the incomplete elliptic integral RD(x,y,z) to the accuracy specified by the mode variable mode.

This routine computes the incomplete elliptic integral RF(x,y,z) to the accuracy specified by the mode variable mode.

This routine computes the incomplete elliptic integral RJ(x,y,z,p) to the accuracy specified by the mode variable mode.

Computes the error function erf(x) = (2/\sqrt(\pi)) \int_0^x dt \exp(-t^2).

Computes the upper tail of the Gaussian probability function Q(x) = (1/(2\pi)) \int_x^\infty dt \exp(-t^2/2).

Computes the Gaussian probability function Z(x) = (1/(2\pi)) \exp(-x^2/2).

Computes the complementary error function erfc(x) = 1 - erf(x) = (2/\sqrt(\pi)) \int_x^\infty \exp(-t^2).

Computes the eta function \eta(s) for arbitrary s.

Computes the eta function \eta(n) for integer n.

These routines exponentiate x and multiply by the factor y to return the product y \exp(x).

Computes the exponential integral Ei_3(x) = \int_0^x dt \exp(-t^3) for x >= 0.

Computes the exponential integral E_1(x),

Computes the second-order exponential integral E_2(x),

Computes the exponential integral E_i(x),

Computes the quantity \exp(x)-1 using an algorithm that is accurate for small x.

Computes the quantity (\exp(x)-1)/x using an algorithm that is accurate for small x.

Computes the quantity 2(\exp(x)-1-x)/x^2 using an algorithm that is accurate for small x.

Computes the N-relative exponential, which is the n-th generalization of the functions gsl_sf_exprel and gsl_sf_exprel2.

Computes the factorial n!.

Computes the complete Fermi-Dirac integral F_{1/2}(x).

Computes the incomplete Fermi-Dirac integral with an index of zero, F_0(x,b) = \ln(1 + e^{b-x}) - (b-x).

Computes the complete Fermi-Dirac integral with an integer index of j, F_j(x) = (1/\Gamma(j+1)) \int_0^\infty dt (t^j /(\exp(t-x)+1)).

Computes the complete Fermi-Dirac integral F_{-1/2}(x).

Computes the Gamma function \Gamma(x), subject to x not being a negative integer.

These functions compute the incomplete Gamma Function the normalization factor included in the previously defined functions: \Gamma(a,x) = \int_x\infty dt t^{a-1} \exp(-t) for a real and x >= 0.

Computes the complementary normalized incomplete Gamma Function P(a,x) = 1/\Gamma(a) \int_0^x dt t^{a-1} \exp(-t) for a > 0, x >= 0.

Computes the normalized incomplete Gamma Function Q(a,x) = 1/\Gamma(a) \int_x\infty dt t^{a-1} \exp(-t) for a > 0, x >= 0.

Computes the reciprocal of the gamma function, 1/\Gamma(x) using the real Lanczos method.

Computes the regulated Gamma Function \Gamma^*(x) for x > 0.

This function computes an array of Gegenbauer polynomials C^{(\lambda)}_n(x) for n = 0, 1, 2, \dots, nmax, subject to \lambda > -1/2, nmax >= 0.

These functions evaluate the Gegenbauer polynomial C^{(\lambda)}_n(x) for n, lambda, x subject to \lambda > -1/2, n >= 0.

The hazard function for the normal distrbution, also known as the inverse Mill\'s ratio, is defined as h(x) = Z(x)/Q(x) = \sqrt{2/\pi \exp(-x^2 / 2) / \erfc(x/\sqrt 2)}.

This routine computes the n-th normalized hydrogenic bound state radial wavefunction,

Computes the hypergeometric function 0F1(c,x).

Primary Confluent Hypergoemetric U function A&E 13.1.3 All inputs are double as is the output.

Primary Confluent Hypergoemetric U function A&E 13.1.3 m and n are integers.

Computes the hypergeometric function 2F0(a,b,x).

Computes the Gauss hypergeometric function 2F1(a,b,c,x) = F(a,b,c,x) for |x| < 1.

Secondary Confluent Hypergoemetric U function A&E 13.1.3 All inputs are double as is the output.

Secondary Confluent Hypergoemetric U function A&E 13.1.3 m and n are integers.

Computes the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.

Computes the generalized Laguerre polynomial L^a_n(x) for a > -1 and n >= 0.

These compute the principal branch of the Lambert W function, W_0(x).

These compute the secondary real-valued branch of the Lambert W function, W_{-1}(x).

These functions evaluate the Legendre polynomial P_l(x) for a specific value of l, x subject to l >= 0, |x| <= 1

These functions compute arrays of Legendre polynomials P_l(x) and derivatives dP_l(x)/dx, for l = 0, \dots, lmax, |x| <= 1.

Computes the associated Legendre polynomial P_l^m(x) for m >= 0, l >= m, |x| <= 1.

Compute arrays of Legendre polynomials P_l^m(x) for m >= 0, l = |m|, ..., lmax, |x| <= 1.

Compute arrays of Legendre polynomials P_l^m(x) and derivatives dP_l^m(x)/dx for m >= 0, l = |m|, ..., lmax, |x| <= 1.

Computes the Legendre function Q_l(x) for x > -1, x != 1 and l >= 0.

Calculate all normalized associated Legendre polynomials for 0 <= l <= lmax and 0 <= m <= l for |x| <= 1.

Calculate all normalized associated Legendre polynomials and their first derivatives for 0 <= l <= lmax and 0 <= m <= l for |x| <= 1.

Computes the normalized associated Legendre polynomial $\sqrt{(2l+1)/(4\pi)} \sqrt{(l-m)!/(l+m)!} P_l^m(x)$ suitable for use in spherical harmonics.

Computes an array of normalized associated Legendre functions sqrt((2l+1)/(4*pi)) * sqrt((l-m)!/(l+m)!) Plm (x) for m >= 0, l = |m|, ..., lmax, |x| <= 1.0

Computes an array of normalized associated Legendre functions sqrt((2l+1)/(4*pi)) * sqrt((l-m)!/(l+m)!) Plm (x) for m >= 0, l = |m|, ..., lmax, |x| <= 1.0 and their derivatives.

Computes the logarithm of the Beta Function, \log(B(a,b)) for a > 0, b > 0.

Computes the logarithm of n choose m.

Computes \log(\cosh(x)) for any x.

Computes the logarithm of the double factorial of n, \log(n!!).

Computes the logarithm of the factorial of n, \log(n!).

Computes the logarithm of the Gamma function, \log(\Gamma(x)), subject to x not a being negative integer.

Computes the logarithm of the Pochhammer symbol, \log((a)_x) = \log(\Gamma(a + x)/\Gamma(a)) for a > 0, a+x > 0.

Computes \log(\sinh(x)) for x > 0.

Computes \log(1 + x) for x > -1 using an algorithm that is accurate for small x.

Computes \log(1 + x) - x for x > -1 using an algorithm that is accurate for small x.

Computes the logarithm of the complementary error function \log(\erfc(x)).

This routine computes the radial j-th kind Mathieu function Mc_n^{(j)}(q,x) of order n.

This routine computes the radial j-th kind Mathieu function Ms_n^{(j)}(q,x) of order n.

Computes the characteristic values a_n(q) of the Mathieu function ce_n(q,x).

Computes the characteristic values b_n(q) of the Mathieu function se_n(q,x).

This routine computes the angular Mathieu function ce_n(q,x).

This routine computes the angular Mathieu function se_n(q,x).

Computes the Pochhammer symbol

Computes the relative Pochhammer symbol ((a,x) - 1)/x where (a,x) = (a)_x := \Gamma(a + x)/\Gamma(a).

Computes the digamma function \psi(x) for general x, x \ne 0.

Computes the Trigamma function \psi(n) for positive integer n.

Computes the real part of the digamma function on the line 1+i y, Re[\psi(1 + i y)].

Computes the polygamma function \psi^{(m)}(x) for m >= 0, x > 0.

Computes \sinc(x) = \sin(\pi x) / (\pi x) for any value of x.

Computes the first synchrotron function x \int_x^\infty dt K_{5/3}(t) for x >= 0.

Computes the second synchrotron function x K_{2/3}(x) for x >= 0.

Computes the Taylor coefficient x^n / n! for x >= 0, n >= 0.

Computes the transport function J(2,x).

Computes the transport function J(3,x).

Computes the transport function J(4,x).

Computes the transport function J(5,x).

Computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.

Computes the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.

Read header of an Analyze 7.5 file.

Read image data of an Analyze 7.5 file.

Write image data to an Analyze 7.5 file.

Uses lookup tables to perform a neighbour operation on binary images.

Calculate block best size for block processing.

Processes image in blocks using user-supplied function.

Estimate total area of objects on the image BW.

Filter objects from image based on their sizes.

Perform area opening.

Trace the boundaries of the objects in a binary image.

Find connected objects.

Compute distance transform in binary image.

Calculate the Euler number of a binary image.

Perform a flood-fill operation on the binary image BW1.

Perform binary hit-or-miss transform.

Label binary 2 dimensional image.

Label foreground objects in the n-dimensional binary image BW.

Perform morphological operation on binary image.

Find perimeter of objects in binary images.

Filter objects from image based on their properties.

Select connected regions in a binary image.

Create checkerboard.

Rearrange block columns back into matrix.

Apply function to matrix blocks

Define a colour map which smoothly traverses the given colors.

Create connectivity array.

Compute correlation coefficients of images.

Return a transformation structure T (see "help maketform" for the form of the structure) that can be further used to transform coordinates between an input space and an ouput space.

Find edges using various methods.

Blur border (edges) of image to prevent ringing artifacts.

Computes the entropy of an image.

Computes the local entropy in a neighbourhood around each pixel in an image.

Determine the Freeman chain code for a boundary.

Convolve 2 dimensional signals using the FFT.

Convolve N dimensional signals using the FFT for computation.

Estimate bounds for spatial transformation.

Create spatial filters for image processing.

Return display range of image.

Calculates the gray-level co-occurrence matrix P of a gray-level image IM.

Create indexed image from intensity image using multilevel thresholding.

Compute global image threshold.

Equalize histogram of grayscale image.

Perform the Hough transform for circles with radius R on the black-and-white image BW.

Calculate the straight line Hough transform of a binary image I.

Perform the Hough transform for lines or circles.

Convert image to binary, black and white, by threshold.

Rearrange blocks from matrix into columns.

Convert image to double precision.

Convert image to int16.

Convert image to single precision.

Convert image to uint16.

Convert image to uint8.

Return absolute difference of image or constant to an image.

Add image or constant to an image.

Adjust image or colormap intensity (values).

Get information about image attributes.

Perform morphological bottom hat filtering.

Convert image to specific data type TYPE.

Clear borders of objects or ligher structures.

Perform morphological closing.

Compute image complement or negative.

Crop image.

Perform morphological dilation.

Reduce the number a colors of rgb or indexed image.

Divide image by another image or constant.

Perform morphological erosion.

Fill image holes or regions.

Computes the linear filtering of the image I and the filter F.

Open GUI dialogue to select image files.

Compute the gradient magnitude and direction in degrees for an image.

Compute the x and y gradients of an image using various methods.

Produce histogram counts of image I.

Combine images linearly.

Find local spatial maximas.

Compute mean squared error.

Multiply image by another image or constant.

Add noise to image.

Perform morphological opening.

Applies the spatial perspective homogeneous transformation P to the image IM.

Get pixel values.

Compute gaussian pyramid expansion or reduction.

Quantize image with multiple threshold levels and values.

See also: imclearborder, imdilate, imerode.

Compute regional maxima.

Compute regional minima.

Applies any geometric transformation to the image IM.

Resize image with interpolation

Rotate image about its center.

Applies a shear to the image M.

Smooth the given image using several different algorithms.

Subtract image or constant to an image.

Perform morphological top hat filtering.

Transform image.

Translate a 2D image by (x,y) using Fourier interpolation.

Convert integer values with lookup table (LUT).

Check if argument is valid connectivity.

Check if argument is valid colormap.

Convert number to ordinal string.

Performs filtered back-projection on the projections in PROJ to reconstruct an approximation of the original image.

Return true if IMG is a black and white image.

Return true if IMG is a grayscale image.

Return true if IMG is an indexed image.

Return true if IMG is a RGB image.

Convert L*a*b* data to double precision.

Transform a colormap or image from CIE L*a*b* to sRGB color space.

Convert L*a*b* data to single precision.

Convert L*a*b* data to uint16 precision.

Convert L*a*b* data to uint8 precision.

Transform a colormap or image from CIE L*a*b* to CIE XYZ color space.

Convert labeled image into RGB.

Create labelled matrix from bwconncomp structure.

Create a lookup table which can be used by applylut.

Create a transform structure T to be used for spatial transformations between an input space and an output space.

Convert a matrix to an intensity image.

Compute the mean value of the 2D image I.

Two dimensional median filtering.

Perform morphological gradient.

Create montage from multiple images.

Process matrix in sliding blocks with user-supplied function.

Performs non-maximum supression on the given edge data.

Compute normalized cross-correlation.

Two dimensional ordered filtering.

N dimensional ordered filtering.

Compute PSF from OTF.

Pad array or matrix.

Create computational phantom head.

Convert a polygon to a region mask.

Compute OTF from PSF.

Compute peak signal-to-noise ratio.

Performs quadtree decomposition.

Obtain block values from a quadtree decomposition.

Set block values in a quadtree decomposition.

Calculates the 2D-Radon transform of the matrix I at angles given in THETA.

Computes the local intensity range in a neighbourhood around each pixel in an image.

Compute properties of image regions.

Convert RGB image or colormap to grayscale.

Transform a colormap or image from sRGB to CIE L*a*b* color space.

Transform a colormap or image from sRGB to CIE XYZ color space.

Convert RGB values to YCbCr.

Filters the parallel ray projections in the columns of PROJ, according to the filter type chosen by TYPE.

Select a Region Of Interest of an image based on color.

Arbitrary rotation and scaling of a gray-scale image using fast bilinear interpolation.

Returns the standard deviation for a 2d real type matrix.

Computes the local standard deviation in a neighbourhood around each pixel in an image.

Find limits to contrast stretch an image.

Display images in subplots.

Given a transform structure T, transform coordinates UV in the input space into coordinates XY in the output space.

Given a transform structure T, transform coordinates XY in the output space into coordinates UV in the input space.

Read value of TAGs from TIFF files.

Compute watershed transform.

Convert wavelength in nm into an RGB value set.

Transform a colormap or image from CIE XYZ to CIE L*a*b* color space.

Transform a colormap or image from CIE XYZ to sRGB color space.

Convert YCbCr color space to RGB.

Returns a struct array with v4l2 devices in /dev/.

Send clear command to Clear GPIB instrument.

Open gpib interface.

Close the interface and release a file descriptor.

Read from gpib interface.

Set new or get existing gpib interface timeout parameter.

Write data to a gpib interface.

Open i2c interface.

Set new or get existing i2c slave device address.

Close the interface and release a file descriptor.

Read from i2c slave device.

Write data to a i2c slave device.

Query available hardware for instrument-control

Open Parallel interface.

Close the interface and release a file descriptor.

Sets or Read the Control lines.

Sets or Read the Data lines.

Controls the Data line drivers.

Reads the Status lines.

Open serial interface.

Serial polls GPIB instruments.

Read from serial interface.

Write data to a serial interface.

Open tcp interface.

Close the interface and release a file descriptor.

Read from tcp interface.

Set new or get existing tcp interface timeout parameter used for tcp_read() requests.

Write data to a tcp interface.

Triggers GPIB instrument.

Open usbtmc interface.

Close the interface and release a file descriptor.

Read from usbtmc slave device.

Write data to a usbtmc slave device.

Open vxi11 interface.

Close the interface and release a file descriptor.

Read from vxi11 slave device.

Write data to a vxi11 slave device.

Evaluate a function in binary64 with correctly rounded result.

Return a contractor function for the intersection of two sets.

Return a contractor function for the union of two sets.

Return the empty interval.

Return the entire set of real numbers.

Create a bare interval.

Create an interval enclosure for a list of parameters.

Decode an interval from its interchange format.

Create an interval enclosureÂ I for [M-R, M+R].

Evaluate a function in binary64 with correctly rounded result.

Return a row vector with N linearly spaced elements between BASE and LIMIT.

Compute the matrix product with binary64 numbers and correctly rounded result.

Compute the lower and upper boundary of the matrix square of interval matrix [XL, XU].

Convert binary64 numbers X to string representation, either exact or correctly rounded.

Compute the dot product of binary64 numbers with correctly rounded result.

Compute the sum S of all numbers in a binary64 vector X with correctly rounded result.

Return the ill-formed decorated interval, called NaI (Not an Interval).

Verified backward error analysis of eigenpairs.

Verified real eigenvector of an interval matrix.

Verified strong solution of interval linear inequalities.

Verified nonnegative invertibility of an interval matrix.

Verified nonnegative solution of a system of linear inequalities.

Verified linear programming.

append_save M-file function

calccelladdress (R, C) - compute spreadsheet style cell address from row & column index (both 1-based).

Create a CSV file from a cell array.

Check Octave environment for spreadsheet I/O support, report any problems, and optionally add or remove Java class libs for spreadsheet support.

Read a CSV (Comma Separated Values) file and convert it into a cell array.

Concatenate a cell into a CSV string or array of strings.

Explode a CSV string into a cell.

Read contents of a dbase (dbf) file, provisionally dbase III+, IV or V.

Write data in a cell array to a dbf (xBase) file, provisionally dBase III+.

Checks whether a file exists.

Get value of attribute ATT in xml node (char string) XMLNODE, return empty if attribute isn't present.

Get a string representing the first xml TAG node starting at position IS in xml text string XML, and return start and end indices.

Try to check proper operation of ODS spreadsheet scripts using interface INTF1.

Try to check proper operation of XLS / XLSX spreadsheet scripts using interface INTF1.

Returns a valid json string that will describe object; the string will be in a compact form (no spaces or line breaks).

Transfer data to an OpenOffice_org Calc (or gnumeric) spreadsheet previously opened by odsopen().

Add data in 1D/2D CELL array ARR into a cell range RANGE in worksheet WSH in an Excel (or gnumeric) spreadsheet file pointed to in structure XLS.

Read data contained within cell range RANGE from worksheet WSH in an OpenOffice_org Calc or Gnumeric spreadsheet file pointed to in struct ODS.

Close the OpenOffice_org Calc / Gnumeric spreadsheet pointed to in struct ODS, if needed write the file to disk.

Query an OpenOffice_org or Gnumeric spreadsheet file FILENAME (with ods or gnumeric suffix) for some info about its contents.

Get a pointer to an OpenOffice_org spreadsheet in the form of return argument ODS.

Read data contained in cell range RANGE in worksheet WSH in OpenOffice_org Calc spreadsheet file FILENAME.

Add data in 1D/2D array ARR into sheet WSH in OpenOffice_org Calc spreadsheet file FILENAME in cell range RANGE.

Divide a heterogeneous 2D cell array into a 2D numeric array and a 2D cell array containing only strings.

Converts NASTRAN PCH file (SORT2) to a data structure and frequency vector.

S = READ_NAMELIST (FILENAME) returns the struct S containing namelists and variables in the file FILENAME organised in hierachical way:

Recursively search for file or filename pattern FNAME starting in directory DNAME and return the first match.

Test functionality of supported spreadsheet interfaces.

Optionally convert character using the function handle in CONV_FCN, remove characters (<32 >255) from text string or cell array ISTR and return the result in OSTR.

Encode (1-byte) Unicode string USTR into UTF-8 OSTR.

Convert UTF-8 encoded strings ISTR to (1-byte) Unicode USTR.

WRITE_NAMELIST(S, FILENAME) writes a namelist data structure S to a file FILENAME.

Read data contained within cell range RANGE from worksheet WSH in an Excel spreadsheet file pointed to in struct XLS; Gnumeric files can be read as well.

Close the Excel spreadsheet pointed to in struct XLS, if needed write the file to disk.

Query Excel spreadsheet file FILENAME for some info about its contents.

Get a pointer to an Excel spreadsheet in the form of return argument (file pointer struct) XLS.

Read data contained in range RANGE from worksheet WSH in Excel spreadsheet file FILENAME.

Add data in 1D/2D array ARR to worksheet WSH in Excel spreadsheet file FILENAME in cell range RANGE.

Parse an xml file FNAME using Xerces Java library and return a Java object representing an xml DOM document.

Write an xml DOM document to file FNAME or to ouput string STR.

Solve the Eikonal equation using the Fast-Marching Method.

Extend the geometry structure GEOM of 'ls_find_geometry' to include absolute coordinates.

Animate the evolution of a level-set geometry.

Build a triangle mesh for the level-set geometry described by GEOM and by the level-set function PHI.

Check a geometric constraint for the level-set function PHI.

Construct a level-set function for the complement of the set described by PHI.

Check if all the sets described by the given level-set functions are disjoint.

Calculate the distance function of a set.

Enforce a geometric constraint for the level-set function PHI.

Enforce geometric constraints by changing the speed field F accordingly.

Check if the sets described by PHI1 and PHI2 are equal.

Calculate a level-set function of an evolving geometry from the result of 'ls_solve_stationary'.

Interpret the level-set function PHI and extract geometrical properties.

Construct the level-set function for a basic geometric shape.

Return a couple of level-set functions for certain 2D cases in the cell-array PHIS.

Approximate the Hausdorff distance between two sets.

Calculate the estimated distances of grid points in the "narrow band" to the zero level-set of PHI.

Return in a logical array which points are inside the domain described by the level-set function PHI.

Calculate a level-set function for the intersection of the sets described by the argument level-set functions.

Check if the set described by PHI is the empty set.

Check if the set described by PHI1 is a subset of PHI2.

Initialise the narrow-band values utilising information about the geometry.

Normalise the level-set function PHI.

Calculate a level-set function for the set difference PHI1 minus PHI2.

Calculate a level-set function for the set "xor" of the two domains given via PHI1 and PHI2.

Construct a colour map that can visibly distinguish between positive and negative values.

Calculate the signed distance function of a set described by its level-set function.

Solve a generalised Eikonal equation with speeds of arbitrary signs.

Evolve the level-set equation with time stepping.

Calculate a level-set function for the union of the sets described by the argument level-set functions.

Construct an example problem for shape optimisation.

Interactively explore a descent file saved by 'so_save_descent'.

Initialise the parameter structure for the shape optimisation routines.

Replay a descent file saved by 'so_save_descent'.

Run a descent method for shape optimisation.

Update handlers to save the descent run to a file.

Perform a line search according to the Armijo rule.

Approximate the gradient norm of PHI using an upwind scheme.

Computes the cartesian product of given column vectors ( row vectors ).

Fast, compact calculation of eigenvalues and eigenvectors of a
circulant matrix
Given an N*1 vector V, return the eigenvalues LAMBDA and optionally
eigenvectors VS of the N*N circulant matrix C tha

Fast, compact calculation of inverse of a circulant matrix
Given an N*1 vector V, return the inverse C of the N*N circulant matrix
C that has V as its first column The returned C is the first column

Produce a full circulant matrix given the first column.

Fast, compact calculation of the product of a circulant matrix with a
vector
Given N*1 vectors V and X, return the matrix-vector product Y = CX,
where C is the N*N circulant matrix that has V as it

Computes the complete orthogonal decomposition (COD) of the matrix A:
A = Q*R*Z'
Let A be an M-by-N matrix, and let `K = min(M, N)'.

Compute condition numbers of the eigenvalues of a matrix.

Compute matrix equivalent of function F; F can be a function name or a
function handle and A must be a square matrix.

Compute the generalised singular value decomposition of (A, B):
u' * a * x = [I 0; 0 c] * [0 r]
v' * b * x = [0 s; 0 0] * [0 r]
c * c + s * s = eye(columns(a))
I and 0 are pa

Solves Hermitian partial eigenproblems using preconditioning.

Computes an n-dimensional covariant linear transform of an n-d tensor,
given a transformation matrix for each dimension.

Nonnegative Matrix Factorization by Alternating Nonnegativity
Constrained Least Squares using Block Principal Pivoting/Active Set
method.

Non-negative matrix factorization by alternative non-negative least
squares using projected gradients.

[x, resids] = pgmres (A, b, x0, rtol, maxit, m, P)

The function w = rotparams (r) - Inverse to rotv().

The functionrotv calculates a Matrix of rotation about V w/ angle |v| r
= rotv(v [,ang])
Returns the rotation matrix w/ axis v, and angle, in radians,
norm(v) or ang (if present).

Solves the square system `(A + U*V')*X == B', where U and V are
matrices with several columns, using the Sherman-Morrison-Woodbury
formula, so that a system with A as left-hand side is actually solv

Trigonometric/hyperbolic functions of square matrix X.

Compute the vector projection of a 3-vector onto another.

Returns the input series, windowed by a polynomial similar to a Hanning window.

Return a series of least-squares transforms of a complex time series via a divide and conquer algorithm.

Return the Lomb Periodogram value at one frequency for a time series.

Return the normalized Lomb Periodogram value at one frequency for a time series.

Return a series of least-squares transforms of a complex-valued time series.

Return the coefficient of the wavelet correlation of two complex time series.

Return a series of least-squares transforms of a real-valued time series.

Return the wavelet transform of a complex time series in a given window.

AMBIGUITYFUNCTION Ambiguity function Usage: A = ambiguityfunction(f); A = ambiguityfunction(f,g);

AUDFILTBW Bandwidth of auditory filter Usage: bw = audfiltbw(fc)

AUDFILTERS Generates filters equidistantly spaced on auditory frequency scales Usage: [g,a,fc,L]=audfilters(fs,Ls); [g,a,fc,L]=audfilters(fs,Ls,...);

AUDSPACE Equidistantly spaced points on auditory scale Usage: y=audspace(fmin,fmax,n,scale);

AUDSPACEBW Auditory scale points specified by bandwidth Usage: y=audspacebw(fmin,fmax,bw,hitme); y=audspacebw(fmin,fmax,bw); y=audspacebw(fmin,fmax); [y,n]=audspacebw

AUDTOFREQ Converts auditory units to frequency (Hz) Usage: freq = audtofreq(aud);

BAT Load the 'bat' test signal Usage: s=bat;

BATMASK Load a Gabor multiplier symbol for the 'bat' test signal Usage: c=batmask;

BLFILTER Construct a band-limited filter Usage: g=blfilter(winname,fsupp,fc); g=blfilter(winname,fsupp,fc,...);

BLOCK Initialize block stream Usage: block(source);

BLOCKANA Blockwise analysis interface Usage: c=blockana(F, f)

BLOCKDEVICES Lists audio devices Usage: devs = blockdevices();

BLOCKDONE Destroy the current blockstream Usage: blockdone();

BLOCKFIGURE Block figure object Usage: p=blockfigure(); p=blockfigure('cm',cmaps);

BLOCKFRAMEACCEL Precompute structures for block processing Usage: F = blockframeaccel(F,Lb);

BLOCKFRAMEPAIRACCEL Precompute structures for block processing Usage: F = blockframepairaccel(Fa,Fs,Lb);

BLOCKPANEL Control panel Usage: blockpanel(params)

BLOCKPANELGET Get parameters from GUI Usage: [par,...] = blockpanelget(p,spar,...)

BLOCKPLAY Schedules block to be played Usage: blockplay(L)

BLOCKPLOT Plot block coefficients Usage: blockplot(p,c); blockplot(p,F,c); blockplot(p,F,c,cola);

BLOCKREAD Read one block from input Usage: f=blockread(L)

BLOCKSYN Blockwise synthesis interface Usage: blocksyn(F, c, Lb)

BLOCKWRITE Append block to an existing file Usage: blockwrite(f);

CAMERAMAN Load the 'cameraman' test image Usage: s=cameraman;

CEIL23 Next number with only 2,3 factors Usage: nceil=ceil23(n);

CEIL235 Next number with only 2,3 and 5 factors Usage: nceil=ceil235(n);

CHIRPZT Chirped Z-transform Usage: c = chirpzt(f,K,fdiff) c = chirpzt(f,K,fdiff,foff) c = chirpzt(f,K,fdiff,foff,fs)

COCKTAILPARTY Load the 'cocktailparty' test signal Usage: s=cocktailparty;

COL2DIAG Move columns of a matrix to diagonals Usage: cout=col2diag(cin);

CONSTRUCTPHASE Construct phase for DGT Usage: c=constructphase(s,g,a); c=constructphase(s,g,a,tol); c=constructphase(c,g,a,tol,mask); c=constructphase(c,g,a,tol,m

CONSTRUCTPHASEREAL Construct phase for DGTREAL Usage: c=constructphasereal(s,g,a,M); c=constructphasereal(s,g,a,M,tol); c=constructphasereal(c,g,a,M,tol,mask); c=

CONVOLVE Convolution Usage: h=convolve(f,g);

CQT Constant-Q non-stationary Gabor filterbank Usage: [c,Ls,g,shift,M] = cqt(f,fmin,fmax,bins,fs,M) [c,Ls,g,shift,M] = cqt(f,fmin,fmax,bins,fs) [c,Ls,g,shift] = cqt(...)

CQTFILTERS CQT-spaced filters Usage: [g,a,fc]=cqtfilters(fs,fmin,fmax,bins,Ls,varargin);

CRESTFACTOR Crest factor of input signal in dB Usage: c=crestfactor(insig);

CTESTFUN Complex 1-D test function Usage: ftest=ctestfun(L);

DCTI Discrete Cosine Transform type I Usage: c=dcti(f); c=dcti(f,L); c=dcti(f,[],dim); c=dcti(f,L,dim);

DCTII Discrete Consine Transform type II Usage: c=dctii(f); c=dctii(f,L); c=dctii(f,[],dim); c=dctii(f,L,dim);

DCTIII Discrete Consine Transform type III Usage: c=dctiii(f); c=dctiii(f,L); c=dctiii(f,[],dim); c=dctiii(f,L,dim);

DCTIV Discrete Consine Transform type IV Usage: c=dctiv(f);

DCTRESAMPLE Resample signal using Fourier interpolation Usage: h=dctresample(f,L); h=dctresample(f,L,dim);

DEMO_AUDIOCOMPRESSION Audio compression using N-term approx

DEMO_AUDIODENOISE Audio denoising using thresholding

DEMO_AUDIOSHRINK Decomposition into tonal and transient parts

DEMO_AUDITORYFILTERBANK Construct an auditory filterbank

DEMO_AUDSCALES Plot of the different auditory scales

DEMO_BLOCKPROC_BASICLOOP Basic real-time audio manipulation Usage: demo_blockproc_basicloop('gspi.wav')

DEMO_BLOCKPROC_DENOISING Variable coefficients thresholding Usage: demo_blockproc_denoising('gspi.wav')

DEMO_BLOCKPROC_DGTEQUALIZER Real-time audio manipulation in the transform domain Usage: demo_blockproc_dgtequalizer('gspi.wav')

DEMO_BLOCKPROC_EFFECTS Various vocoder effects using DGT Usage: demo_blockproc_effects('gspi.wav')

DEMO_BLOCKPROC_PARAMEQUALIZER Real-time equalizer demonstration Usage: demo_blockproc_paramequalizer('gspi.wav')

DEMO_BLOCKPROC_SLIDINGCQT Basic real-time rolling CQT-spectrogram visualization Usage: demo_blockproc_slidingcqt('gspi.wav')

DEMO_BLOCKPROC_SLIDINGERBLETS Basic real-time rolling erblet-spectrogram visualization Usage: demo_blockproc_slidingerblets('gspi.wav')

DEMO_BLOCKPROC_SLIDINGSGRAM Basic real-time rolling spectrogram visualization Usage: demo_blockproc_slidingsgram('gspi.wav')

DEMO_BPFRAMEMUL Frame multiplier acting as a time-varying bandpass filter

DEMO_DGT Basic introduction to DGT analysis/synthesis

DEMO_FILTERBANKS CQT, ERBLET and AUDLET filterbanks

DEMO_FILTERBANKSYNCHROSQUEEZE Filterbank synchrosqueezing and inversion

DEMO_FRAMEMUL Time-frequency localization by a Gabor multiplier

DEMO_FRSYNABS Construction of a signal with a given spectrogram

DEMO_GABFIR Working with FIR windows

DEMO_GABMIXDUAL How to use GABMIXDUAL

DEMO_GABMULAPPR Approximate a slowly time variant system by a Gabor multiplier

DEMO_IMAGECOMPRESSION Image compression using N-term approximation

DEMO_NEXTFASTFFT Next fast FFT number

DEMO_NSDGT Non-stationary Gabor transform demo

DEMO_OFDM Demo of Gabor systems used for OFDM

DEMO_PBSPLINE How to use PBSPLINE

DEMO_PGAUSS How to use PGAUSS

DEMO_PHASEPLOT Give demos of nice phaseplots

DEMO_PHASERET Phase retrieval and phase difference

DEMO_WAVELETS Wavelet filter banks

DEMO_WFBT Auditory filterbanks built using filterbank tree structures

DFRACFT Discrete Fractional Fourier transform Usage: V=dfracft(f,a,p); V=dfracft(f,a);

DFT Normalized Discrete Fourier Transform Usage: f=dft(f); f=dft(f,N,dim);

DGT Discrete Gabor transform Usage: c=dgt(f,g,a,M); c=dgt(f,g,a,M,L); c=dgt(f,g,a,M,'lt',lt); [c,Ls]=dgt(...);

DGT2 2-D Discrete Gabor transform Usage: c=dgt2(f,g,a,M); c=dgt2(f,g1,g2,[a1,a2],[M1,M2]); c=dgt2(f,g1,g2,[a1,a2],[M1,M2],[L1,L2]); [c,Ls]=dgt2(f,g1,g2,[a1,a2],[M1,M2

DGTLENGTH DGT length from signal Usage: L=dgtlength(Ls,a,M); L=dgtlength(Ls,a,M,lt);

DGTREAL Discrete Gabor transform for real-valued signals Usage: c=dgtreal(f,g,a,M); c=dgtreal(f,g,a,M,L); [c,Ls]=dgtreal(f,g,a,M); [c,Ls]=dgtreal(f,g,a,M,L);

DRIHACZEKDIST discrete Rihaczek distribution Usage r = drihaczekdist(f);

DSFT Discrete Symplectic Fourier Transform Usage: C=dsft(F);

DSTI Discrete Sine Transform type I Usage: c=dsti(f); c=dsti(f,L); c=dsti(f,[],dim); c=dsti(f,L,dim);

DSTII Discrete Sine Transform type II Usage: c=dstii(f); c=dstii(f,L); c=dstii(f,[],dim); c=dstii(f,L,dim);

DSTIII Discrete sine transform type III Usage: c=dstiii(f); c=dstiii(f,L); c=dstiii(f,[],dim); c=dstiii(f,L,dim);

DSTIV Discrete Sine Transform type IV Usage: c=dstiv(f); c=dstiv(f,L); c=dstiv(f,[],dim); c=dstiv(f,L,dim);

DTWFB Dual-Tree Wavelet Filter Bank Usage: c=dtwfb(f,dualwt); c=dtwfb(f,{dualw,J}); [c,info]=dtwfb(...);

DTWFB2FILTERBANK DTWFB equivalent non-iterated filterbank Usage: [g,a] = dtwfb2filterbank(dualwt) [g,a,info] = dtwfb2filterbank(...)

DTWFBBOUNDS Frame bounds of DTWFB Usage: fcond=dtwfbbounds(dualwt,L); [A,B]=dtwfbbounds(dualwt,L); [...]=dtwfbbounds(dualwt);

DTWFBINIT Dual-Tree Wavelet Filterbank Initialization Usage: dualwt=dtwfbinit(dualwtdef);

DTWFBREAL Dual-Tree Wavelet FilterBank for real-valued signals Usage: c=dtwfbreal(f,dualwt); c=dtwfbreal(f,{dualw,J}); [c,info]=dtwfbreal(...);

DWILT Discrete Wilson transform Usage: c=dwilt(f,g,M); c=dwilt(f,g,M,L); [c,Ls]=dwilt(...);

DWILT2 2D Discrete Wilson transform Usage: c=dwilt2(f,g,M); c=dwilt2(f,g1,g2,[M1,M2]); c=dwilt2(f,g1,g2,[M1,M2],[L1,L2]); [c,Ls]=dwilt2(f,g1,g2,[M1,M2],[L1,L2]);

DWILTLENGTH DWILT/WMDCT length from signal Usage: L=dwiltlength(Ls,M);

DYNLIMIT Limit the dynamical range of the input Usage: xo=dynlimit(xi,dynrange);

ERBFILTERS ERB-spaced filters Usage: [g,a,fc,L]=erbfilters(fs,Ls); [g,a,fc,L]=erbfilters(fs,Ls,...);

ERBLETT ERBlet non-stationary Gabor filterbank Usage: [c,Ls,g,shift,M] = erblett(f,bins,fs,varargin) [c,Ls,g,shift] = erblett(...) [c,Ls] = erblett(...) c = erblett(.

ERBSPACE Equidistantly spaced points on erbscale Usage: y=erbspace(fmin,fmax,n);

ERBSPACEBW Erbscale points specified by bandwidth Usage: y=erbspacebw(fmin,fmax,bw,hitme); y=erbspacebw(fmin,fmax,bw); y=erbspacebw(fmin,fmax);

ERBTOFREQ Converts erb units to frequency (Hz) Usage: freq = erbtofreq(erb);

EXPCHIRP Exponential chirp Usage: outsig=expchirp(L,fstart,fend)

EXPWAVE Complex exponential wave Usage: h=expwave(L,m); h=expwave(L,m,cent);

FFRACFT Approximate fast fractional Fourier transform Usage: frf=ffracft(f,a) frf=ffracft(f,a,dim)

FFTANALYTIC Compute analytic representation Usage: z = fftanalytic(f); z = fftanalytic(f,L); z = fftanalytic(f,L,dim);

FFTGRAM Plot the energy of the discrete Fourier transform Usage: fftgram(f) fftgram(f, fs)

FFTINDEX Frequency index of FFT modulations Usage: n=fftindex(N);

FFTREAL FFT for real valued input data Usage: f=fftreal(f); f=fftreal(f,N,dim);

FFTRESAMPLE Resample signal using Fourier interpolation Usage: h=fftresample(f,L); h=fftresample(f,L,dim);

FILTERBANK Apply filterbank Usage: c=filterbank(f,g,a);

FILTERBANKBOUNDS Frame bounds of a filterbank Usage: fcond=filterbankbounds(g,a,L); [A,B]=filterbankbounds(g,a,L); [...]=filterbankbounds(g,a);

FILTERBANKDUAL Dual filters Usage: gd=filterbankdual(g,a,L); gd=filterbankdual(g,a);

FILTERBANKFREQZ Filterbank frequency responses Usage: gf = filterbankfreqz(g,a,L)

FILTERBANKLENGTH Filterbank length from signal Usage: L=filterbanklength(Ls,a);

FILTERBANKLENGTHCOEF Filterbank length from coefficients Usage: L=filterbanklengthcoef(coef,a);

FILTERBANKPHASEGRAD Phase gradient of a filterbank representation Usage: [tgrad,fgrad,s,c] = filterbankphasegrad(f,g,a,L,minlvl); [tgrad,fgrad,s,c] = filterbankphasegrad(f,g,a,L);

FILTERBANKREALBOUNDS Frame bounds of filter bank for real signals only Usage: fcond=filterbankrealbounds(g,a,L); [A,B]=filterbankrealbounds(g,a,L); [...]=filterbankrealbounds(g

FILTERBANKREALDUAL Dual filters of filterbank for real signals only Usage: gd=filterbankrealdual(g,a,L); gd=filterbankrealdual(g,a);

FILTERBANKREALTIGHT Tight filters of filterbank for real signals only Usage: gt=filterbankrealtight(g,a,L); gt=filterbankrealtight(g,a);

FILTERBANKREASSIGN Reassign filterbank spectrogram Usage: sr = filterbankreassign(s,tgrad,fgrad,a,cfreq); sr = filterbankreassign(s,tgrad,fgrad,a,g); [sr,repos,Lc] = filterb

FILTERBANKRESPONSE Response of filterbank as function of frequency Usage: gf=filterbankresponse(g,a,L);

FILTERBANKSCALE Scale filters in filterbank Usage: g=filterbankscale(g,scal) g=filterbankscale(g,'flag') g=filterbankscale(g,L,'flag')

FILTERBANKSYNCHROSQUEEZE Synchrosqueeze filterbank spectrogram Usage: cr = filterbanksynchrosqueeze(c,tgrad,cfreq); cr = filterbanksynchrosqueeze(c,tgrad,g); [cr,repos,Lc] =

FILTERBANKTIGHT Tight filterbank Usage: gt=filterbanktight(g,a,L); gt=filterbanktight(g,a);

FILTERBANKWIN Compute set of filter bank windows from text or cell array Usage: [g,info] = filterbankwin(g,a,L);

FIR2LONG Extend FIR window to LONG Usage: g=fir2long(g,Llong);

FIRFILTER Construct an FIR filter Usage: g=firfilter(name,M); g=firfilter(name,M,...);

FIRKAISER Kaiser-Bessel window Usage: g=firkaiser(L,beta); g=firkaiser(L,beta,...);

FIRWIN FIR window Usage: g=firwin(name,M); g=firwin(name,M,...); g=firwin(name,x);

FLOOR23 Previous number with only 2,3 factors Usage: nceil=floor23(n);

FLOOR235 Previous number with only 2,3 and 5 factors Usage: nfloor=floor235(n);

FRAME Construct a new frame Usage: F=frame(ftype,...);

FRAMEACCEL Precompute structures Usage: F=frameaccel(F,Ls);

FRAMEBOUNDS Frame bounds Usage: fcond=framebounds(F); [A,B]=framebounds(F); [...]=framebounds(F,Ls);

FRAMECLENGTH Number of coefficients from length of signal Usage: Ncoef=frameclength(F,Ls); [Ncoef,L]=frameclength(...);

FRAMECOEF2NATIVE Convert coefficients to native format Usage: coef=framecoef2native(F,coef);

FRAMECOEF2TF Convert coefficients to time-frequency plane Usage: cout=framecoef2tf(F,cin);

FRAMECOEF2TFPLOT Convert coefficients to time-frequency plane matrix Usage: cout=framecoef2tfplot(F,cin);

FRAMEDIAG Compute the diagonal of the frame operator Usage: d=framediag(F,L);

FRAMEDUAL Construct the canonical dual frame Usage: Fd=framedual(F);

FRAMEGRAM Easy visualization of energy in transform domain Usage: framegram(F,x,...);

FRAMELENGTH Frame length from signal Usage: L=framelength(F,Ls);

FRAMELENGTHCOEF Frame length from coefficients Usage: L=framelengthcoef(F,Ncoef);

FRAMEMATRIX Frame synthesis operator matrix Usage: G=framematrix(F,L);

FRAMEMUL Frame multiplier Usage: h=framemul(f,Fa,Fs,s);

FRAMEMULADJ Adjoint operator of frame multiplier Usage: h=framemuladj(f,Fa,Fs,s);

FRAMEMULAPPR Best Approximation of a matrix by a frame multiplier Usage: s=framemulappr(Fa,Fs,T); [s,TA]=framemulappr(Fa,Fs,T);

FRAMEMULEIGS Eigenpairs of frame multiplier Usage: [V,D]=framemuleigs(Fa,Fs,s,K); D=framemuleigs(Fa,Fs,s,K,...);

FRAMENATIVE2COEF Convert coefficient from native format Usage: coef=framenative2coef(F,coef);

FRAMEOPERATOR Frame Operator Usage: o=frameoperator(F, f);

FRAMEPAIR Construct a new frame Usage: [F1,F2]=framepair(ftype,g1,g2,...);

FRAMERED Redundancy of a frame Usage red=framered(F);

FRAMETF2COEF Convert coefficients from TF-plane format Usage: cout=frametf2coef(F,cin);

FRAMETIGHT Construct the canonical tight frame Usage: Ft=frametight(F);

FRANA Frame analysis operator Usage: c=frana(F,f);

FRANABP Frame Analysis Basis Pursuit Usage: c = franabp(F,f) c = franabp(F,f,lambda,C,tol,maxit) [c,relres,iter,frec,cd] = franabp(...)

FRANAGROUPLASSO Group LASSO regression in the TF-domain Usage: tc = franagrouplasso(F,f,lambda) tc = franagrouplasso(F,f,lambda,C,tol,maxit) [tc,relres,iter,frec] = franagroupl

FRANAITER Iterative analysis Usage: c=franaiter(F,f); [c,relres,iter]=franaiter(F,f,...);

FRANALASSO Frame LASSO regression Usage: tc = franalasso(F,f,lambda) tc = franalasso(F,f,lambda,C,tol,maxit) [tc,relres,iter,frec,cd] = franalasso(...)

FREQFILTER Construct filter in frequency domain Usage: g=freqfilter(winname,bw); g=freqfilter(winname,bw,fc);

FREQTOAUD Converts frequencies (Hz) to auditory scale units Usage: aud = freqtoaud(freq,scale);

FREQTOERB Converts frequencies (Hz) to erbs Usage: erb = freqtoerb(freq);

FREQWIN Frequency response window Usage: H = freqwin(name,L,bw);

FRGRAMIAN Frame Gramian operator Usage: o=frgramian(c, F); o=frgramian(c, Fa, Fs);

FRSYN Frame synthesis operator Usage: f=frsyn(F,c);

FRSYNABS Reconstruction from magnitude of coefficients Usage: f=frsynabs(F,s); f=frsynabs(F,s,Ls); [f,relres,iter,c]=frsynabs(...);

FRSYNITER Iterative synthesis Usage: f=frsyniter(F,c); f=frsyniter(F,c,Ls); [f,relres,iter]=frsyniter(F,c,...);

FRSYNMATRIX Frame synthesis operator matrix Usage: G=frsynmatrix(F,L);

FWT Fast Wavelet Transform Usage: c = fwt(f,w,J); c = fwt(f,w,J,dim); [c,info] = fwt(...);

FWT2 Fast Wavelet Transform 2D Usage: c = fwt2(f,w,J); c = fwt2(f,w,J,...);

FWTCLENGTH FWT subbands lengths from a signal length Usage: Lc=fwtclength(Ls,w,J); [Lc,L]=fwtclength(...);

FWTINIT Wavelet Filterbank Structure Initialization Usage: w = fwtinit(wdef); w = fwtinit(wdef,prefix); [w,info]=fwtinit(...)

FWTLENGTH FWT length from signal Usage: L=fwtlength(Ls,w,J);

GABCONVEXOPT Compute a window using convex optimization Usage: gout=gabconvexopt(g,a,M); gout=gabconvexopt(g,a,M, varagin);

GABDUAL Canonical dual window of Gabor frame Usage: gd=gabdual(g,a,M); gd=gabdual(g,a,M,L); gd=gabdual(g,a,M,'lt',lt);

GABDUALNORM Measure of how close a window is to being a dual window Usage: dn=gabdualnorm(g,gamma,a,M); dn=gabdualnorm(g,gamma,a,M,L); dn=gabdualnorm(g,gamma,a,M,'lt',lt);

GABELITISTLASSO Elitist LASSO regression in Gabor domain Usage: [tc,xrec] = gabelitistlasso(x,g,a,M,lambda,C,tol,maxit) Input parameters: x : Input signal g : Synthe

GABFIRDUAL Compute FIR dual window Usage: gd=gabfirdual(Ldual,g,a,M); gd=gabfirdual(Ldual,g,a,M, varagin);

GABFIRTIGHT Compute FIR tight window Usage: gt=gabfirtight(Lsupport,g,a,M); gt=gabfirtight(Lsupport,g,a,M, varagin);

GABFRAMEBOUNDS Calculate frame bounds of Gabor frame Usage: fcond=gabframebounds(g,a,M); [A,B]=gabframebounds(g,a,M); [A,B]=gabframebounds(g,a,M,L); [A,B]=gabfram

GABFRAMEDIAG Diagonal of Gabor frame operator Usage: d=gabframediag(g,a,M,L); d=gabframediag(g,a,M,L,'lt',lt);

GABGROUPLASSO Group LASSO regression in Gabor domain Usage: [tc,xrec] = gabgrouplasso(x,g,a,M,group,lambda,C,maxit,tol)

GABIMAGEPARS Find Gabor parameters to generate image Usage: [a,M,L,N,Ngood]=gabimagepars(Ls,x,y);

GABLASSO LASSO regression in Gabor domain Usage: [tc,xrec] = gablasso(x,a,M,lambda,C,tol,maxit)

GABMIXDUAL Computes the mixdual of g1 Usage: gamma=mixdual(g1,g2,a,M)

GABMUL Apply Gabor multiplier Usage: h=gabmul(f,c,a); h=gabmul(f,c,g,a); h=gabmul(f,c,ga,gs,a);

GABMULAPPR Best Approximation by a Gabor multiplier Usage: sym=gabmulappr(T,a,M); sym=gabmulappr(T,g,a,M); sym=gabmulappr(T,ga,gs,a,M); [sym,lowb,upb]=gabmulappr(

GABMULEIGS Eigenpairs of Gabor multiplier Usage: h=gabmuleigs(K,c,g,a); h=gabmuleigs(K,c,a); h=gabmuleigs(K,c,ga,gs,a);

GABOPTDUAL Compute dual window Usage: gd=gaboptdual(g,a,M); gd=gaboptdual(g,a,M, varagin);

GABOPTTIGHT Compute a optimized tight window Usage: gt=gabopttight(Ltight,g,a,M); gt=gabopttight(Ltight,g,a,M, varagin);

GABPHASEDERIV DGT phase derivatives Usage: [phased,c] = gabphasederiv(dflag,'dgt',f,g,a,M); phased = gabphasederiv(dflag,'cross',f,g,a,M) phased = gabphasederiv(dfl

GABPHASEGRAD Phase gradient of the DGT Usage: [tgrad,fgrad,c] = gabphasegrad('dgt',f,g,a,M); [tgrad,fgrad] = gabphasegrad('phase',cphase,a); [tgrad,fgrad] = gabphasegra

GABPROJDUAL Gabor Dual window by projection Usage: gd=gabprojdual(gm,g,a,M) gd=gabprojdual(gm,g,a,M,L)

GABREASSIGN Reassign time-frequency distribution Usage: sr = gabreassign(s,tgrad,fgrad,a);

GABREASSIGNADJUST Adjustable reassignment of a time-frequency distribution Usage: sr = gabreassignadjust(s,pderivs,a,mu);

GABRIESZBOUNDS Calculate Riesz sequence/basis bounds of Gabor frame Usage: fcond=gabrieszbounds(g,a,M); [A,B]=gabrieszbounds(g,a,M); [A,B]=gabrieszbounds(g,a,M,L);

GABTIGHT Canonical tight window of Gabor frame Usage: gt=gabtight(a,M,L); gt=gabtight(g,a,M); gt=gabtight(g,a,M,L); gd=gabtight(g,a,M,'lt',lt);

GABWIN Compute a Gabor window from text or cell array Usage: [g,info] = gabwin(g,a,M,L);

GAINDB Increase/decrease level of signal Usage: outsig = gaindb(insig,gn);

GAMMATONEFIR Gammatone filter coefficients Usage: b = gammatonefir(fc,fs,n,betamul); b = gammatonefir(fc,fs,n); b = gammatonefir(fc,fs);

GGA Generalized Goertzel algorithm Usage: c = gga(x,fvec) c = gga(x,fvec,fs)

GREASY Load the 'greasy' test signal Usage: s=greasy;

GROUPTHRESH Group thresholding Usage: xo=groupthresh(xi,lambda);

GSPI Load the 'glockenspiel' test signal

HERMBASIS Orthonormal basis of discrete Hermite functions Usage: V=hermbasis(L,p); V=hermbasis(L); [V,D]=hermbasis(...);

ICQT Constant-Q non-stationary Gabor synthesis Usage: fr = icqt(c,g,shift,Ls,dual) fr = icqt(c,g,shift,Ls) fr = icqt(c,g,shift)

IDFT Inverse normalized Discrete Fourier Transform Usage: f=idft(c); f=idft(c,N,dim);

IDGT Inverse discrete Gabor transform Usage: f=idgt(c,g,a); f=idgt(c,g,a,Ls); f=idgt(c,g,a,Ls,lt);

IDGT2 2D Inverse discrete Gabor transform Usage: f=idgt2(c,g,a); f=idgt2(c,g1,g2,a); f=idgt2(c,g1,g2,[a1 a2]); f=idgt2(c,g,a,Ls); f=idgt2(c,g1,g2,a,Ls);

IDGTREAL Inverse discrete Gabor transform for real-valued signals Usage: f=idgtreal(c,g,a,M); f=idgtreal(c,g,a,M,Ls);

IDTWFB Inverse Dual-tree Filterbank Usage: f=idtwfb(c,info); f=idtwfb(c,dualwt,Ls);

IDTWFBREAL Inverse Dual-tree Filterbank for real-valued signals Usage: f=idtwfbreal(c,info); f=idtwfbreal(c,dualwt,Ls);

IDWILT Inverse discrete Wilson transform Usage: f=idwilt(c,g); f=idwilt(c,g,Ls);

IDWILT2 2D Inverse Discrete Wilson transform Usage: f=idwilt2(c,g); f=idwilt2(c,g1,g2); f=idwilt2(c,g1,g2,Ls);

IERBLETT ERBlet non-stationary Gabor synthesis Usage: fr = ierblett(c,g,shift,Ls,dual) fr = ierblett(c,g,shift,Ls) fr = ierblett(c,g,shift)

IFFTREAL Inverse FFT for real valued signals Usage: f=ifftreal(c,N); f=ifftreal(c,N,dim);

IFILTERBANK Filter bank inversion Usage: f=ifilterbank(c,g,a);

IFILTERBANKITER Filter bank iterative inversion Usage: f=ifilterbankiter(c,g,a);

IFRAMEMUL Inverse of frame multiplier Usage: h=iframemul(f,Fa,Fs,s); [h,relres,iter]=iframemul(...);

IFWT Inverse Fast Wavelet Transform Usage: f = ifwt(c,info) f = ifwt(c,w,J,Ls) f = ifwt(c,w,J,Ls,dim)

IFWT2 Inverse Fast Wavelet Transform Usage: f = ifwt2(c,w,J) f = ifwt2(c,w,J,Ls,...)

INSDGT Inverse non-stationary discrete Gabor transform Usage: f=insdgt(c,g,a,Ls);

INSDGTREAL Inverse NSDGT for real-valued signals Usage: f=insdgt(c,g,a,M,Ls);

INSTFREQPLOT Plot of instantaneous frequency Usage: instfreqplot(f,op1,op2, ...

INVOLUTE Involution Usage: finv=involute(f); finv=involute(f,dim);

IOPERATOR Apply inverse of operator Usage: c=ioperator(Op,f);

IQAM4 Inverse QAM of order 4

ISEVENFUNCTION True if function is even Usage: t=isevenfunction(f); t=isevenfunction(f,tol);

ISGRAM Spectrogram inversion Usage: f=isgram(c,g,a); f=isgram(c,g,a,Ls); [f,relres,iter]=isgram(...);

ISGRAMREAL Spectrogram inversion (real signal) Usage: f=isgramreal(s,g,a,M); f=isgramreal(s,g,a,M,Ls); [f,relres,iter]=isgramreal(...);

ISOCTAVE True if the operating environment is octave Usage: t=isoctave();

IUFILTERBANK Filter bank inversion, DEPRECATED Usage: f=iufilterbank(c,g,a);

IUFWT Inverse Undecimated Fast Wavelet Transform Usage: f = iufwt(c,info) f = iufwt(c,w,J);

IUNSDGT Inverse uniform non-stationary discrete Gabor transform Usage: f=iunsdgt(c,g,a,Ls);

IUNSDGTREAL Inverse uniform non-stationary discrete Gabor transform Usage: f=iunsdgtreal(c,g,a,M,Ls);

IUWFBT Inverse Undecimated Wavelet Filterbank Tree Usage: f = iuwfbt(c,info) f = iuwfbt(c,wt)

IUWPFBT Inverse Undecimated Wavelet Packet Filterbank Tree Usage: f=iuwpfbt(c,info); f=iuwpfbt(c,wt);

IWFBT Inverse Wavelet Filterbank Tree Usage: f=iwfbt(c,info); f=iwfbt(c,wt,Ls);

IWMDCT Inverse MDCT Usage: f=iwmdct(c,g); f=iwmdct(c,g,Ls);

IWMDCT2 2D Inverse windowed MDCT transform Usage: f=iwmdct2(c,g); f=iwmdct2(c,g1,g2); f=iwmdct2(c,g1,g2,Ls);

IWPFBT Inverse Wavelet Packet Filterbank Tree Usage: f=iwpfbt(c,info); f=iwpfbt(c,wt,Ls);

IZAK Inverse Zak transform Usage: f=izak(c);

JPEG2RGB Coverts from RGB format to YCbCr format Usage: RGB = jpeg2rgb(YCbCr);

LARGESTN Keep N largest coefficients Usage: xo=largestn(x,N); xo=largestn(x,N,mtype);

LARGESTR Keep fixed ratio of largest coefficients Usage: xo=largestr(x,p); xo=largestr(x,p,mtype); [xo,N]=largestr(...);

LATTICETYPE2MATRIX Convert lattice description to matrix form Usage: V=latticetype2matrix(L,a,M,lt);

LCONV Linear convolution Usage: h=lconv(f,g);

LICHTENSTEIN Load the 'lichtenstein' test image Usage: s=lichtenstein;

LINUS Load the 'linus' test signal Usage: s=linus;

LONG2FIR Cut LONG window to FIR Usage: g=long2fir(g,L);

LTFATARGHELPER Parse arguments for LTFAT Usage: [flags,varargout] = ltfatarghelper(posdepnames,definput,arglist,callfun);

LTFATBASEPATH The base path of the LTFAT installation Usage: bp = ltfatbasepath;

LTFATGETDEFAULTS Get default parameters of function

LTFATHELP Help on the LTFAT toolbox Usage: ltfathelp; v=ltfathelp('version'); mlist=ltfathelp('modules');

LTFATLOGO Load the 'ltfatlogo' test signal Usage: s=ltfatlogo;

LTFATMEX Compile Mex/Oct interfaces Usage: ltfatmex; ltfatmex(...);

LTFATPLAY Play data samples or a wav file Usage: ltfatplay('file.wav') ltfatplay(data,'fs',fs) ltfatplay(...,'devid',devid)

LTFATSETDEFAULTS Set default parameters of function

LTFATSTART Start the LTFAT toolbox Usage: ltfatstart;

LTFATSTOP Stops the LTFAT toolbox Usage: ltfatstop;

LTFATTEXT Load the 'ltfattext' test image Usage: s=ltfattext;

LXCORR Linear crosscorrelation Usage: h=lxcorr(f,g)

MAGRESP Magnitude response plot of window Usage: magresp(g,...); magresp(g,fs,...); magresp(g,fs,dynrange,....);

MATRIX2LATTICETYPE Convert matrix form to standard lattice description Usage: [a,M,lt] = matrix2latticetype(L,V);

MIDDLEPAD Symmetrically zero-extends or cuts a function Usage: h=middlepad(f,L); h=middlepad(f,L,dim); h=middlepad(f,L,...);

MODCENT Centered modulo Usage: y=modcent(x,r);

MULACLAB Graphical interface for audio processing using frame multipliers Usage: mulaclab; mulaclab(filename); mulaclab(signal, fs);

NEXTFASTFFT Next higher number with a fast FFT Usage: nfft=nextfastfft(n);

NOISE Stochastic noise generator Usage: outsig = noise(siglen,nsigs,type);

NONU2UCFMT Non-uniform to uniform filterbank coefficient format Usage: cu=nonu2ucfmt(c,pk)

NONU2UFILTERBANK Non-uniform to uniform filterbank transform Usage: [gu,au]=nonu2ufilterbank(g,a)

NORMALIZE Normalize input signal by specified norm Usage: h=normalize(f,...);

NOSHEARLENGTH Transform length that does not require a frequency shear Usage: L=noshearlength(Ls,a,M,lt)

NSDGT Non-stationary Discrete Gabor transform Usage: c=nsdgt(f,g,a,M); [c,Ls]=nsdgt(f,g,a,M);

NSDGTREAL Non-stationary Discrete Gabor transform for real valued signals Usage: c=nsdgtreal(f,g,a,M); [c,Ls]=nsdgtreal(f,g,a,M);

NSGABDUAL Canonical dual window for non-stationary Gabor frames Usage: gd=nsgabdual(g,a,M); gd=nsgabdual(g,a,M,L);

NSGABFRAMEBOUNDS Frame bounds of non-stationary Gabor frame Usage: fcond=nsgabframebounds(g,a,M); [A,B]=nsgabframebounds(g,a,M);

NSGABFRAMEDIAG Diagonal of Gabor frame operator Usage: d=nsgabframediag(g,a,M);

NSGABTIGHT Canonical tight window for non-stationary Gabor frames Usage: gt=nsgabtight(g,a,M); gt=nsgabtight(g,a,M,L);

OPERATOR Apply operator Usage: c=operator(Op,f);

OPERATORADJ Apply the adjoint of an operator Usage: c=operatoradj(Op,f);

OPERATORAPPR Best approximation by operator Usage: c=operatorappr(Op,K);

OPERATOREIGS Apply the adjoint of an operator Usage: c=operatoreigs(Op,K);

OPERATORMATRIX Matrix representation of an operator Usage: T=operatormatrix(Op);

OPERATORNEW Construct a new operator Usage: F=operatornew(otype,...);

OTOCLICK Load the 'otoclick' test signal Usage: s=otoclick;

PBSPLINE Periodized B-spline Usage: g=pbspline(L,order,a,...); [g,nlen]=pbspline(L,order,a,...);

PCHIRP Periodic chirp Usage: g=pchirp(L,n);

PCONV Periodic convolution Usage: h=pconv(f,g) h=pconv(f,g,ftype);

PDERIV Derivative of smooth periodic function Usage: fd=pderiv(f); fd=pderiv(f,dim); fd=pderiv(f,dim,difforder);

PEBFUN Sampled, periodized EB-spline Usage: g=pebfun(L,w) g=pebfun(L,w,width) [g,nlen]=pebfun(...)

PEBFUNDUAL Dual window of sampled, periodized EB-spline Usage: g=pebfundual(w,a,M,L) g=pebfundual({w,width},a,M,L) g=pebfundual(...,inc)

PEVEN Even part of periodic function Usage: fe=peven(f); fe=peven(f,dim);

PFILT Apply filter with periodic boundary conditions Usage: h=pfilt(f,g); h=pfilt(f,g,a,dim);

PGAUSS Sampled, periodized Gaussian Usage: g=pgauss(L); g=pgauss(L,tfr); g=pgauss(L,...); [g,tfr]=pgauss( ...

PGRPDELAY Group delay of a filter with periodic boundaries Usage: ggd = pgrpdelay(g,L);

PHASELOCK Phaselock Gabor coefficients Usage: c=phaselock(c,a);

PHASELOCKREAL Phaselock Gabor coefficients Usage: c=phaselockreal(c,a,M);

PHASEPLOT Phase plot Usage: phaseplot(f,op1,op2, ...

PHASEUNLOCK Undo phase lock of Gabor coefficients Usage: c=phaseunlock(c,a);

PHASEUNLOCKREAL Undo phase lock of Gabor coefficients Usage: c=phaseunlockreal(c,a,M);

PHEAVISIDE Periodic Heaviside function Usage: h=pheaviside(L);

PHERM Periodized Hermite function Usage: g=pherm(L,order); g=pherm(L,order,tfr); [g,D]=pherm(...);

PINKNOISE Generates a pink noise signal Usage: outsig = pinknoise(siglen,nsigs);

PLOTDGT Plot DGT coefficients Usage: plotdgt(coef,a); plotdgt(coef,a,fs); plotdgt(coef,a,fs,dynrange);

PLOTDGTREAL Plot DGTREAL coefficients Usage: plotdgtreal(coef,a,M); plotdgtreal(coef,a,M,fs); plotdgtreal(coef,a,M,fs,dynrange);

PLOTDWILT Plot DWILT coefficients Usage: plotdwilt(coef); plotdwilt(coef,fs); plotdwilt(coef,fs,dynrange);

PLOTFFT Plot the output from FFT Usage: plotfft(coef); plotfft(coef,fs);

PLOTFFTREAL Plot the output from FFTREAL Usage: plotfftreal(coef); plotfftreal(coef,fs);

PLOTFILTERBANK Plot filterbank and ufilterbank coefficients Usage: plotfilterbank(coef,a); plotfilterbank(coef,a,fc); plotfilterbank(coef,a,fc,fs); plotfilterbank(

PLOTFRAME Plot frame coefficients Usage: plotframe(F,c,â€¦); C = plotframe(...);

PLOTNSDGT Plot non-stationary Gabor coefficients Usage: plotnsdgt(c,a,fs,dynrange);

PLOTNSDGTREAL Plot NSDGTREAL coefficients Usage: plotnsdgtreal(c,a,fs,dynrange);

PLOTQUADTFDIST Plot quadratic time-frequency distribution Usage: plotquadtfdist(p);

PLOTWAVELETS Plot wavelet coefficients Usage: plotwavelets(c,info,fs) plotwavelets(c,info,fs,'dynrange',dynrange,...)

PLOTWMDCT Plot WMDCT coefficients Usage: plotwmdct(coef); plotwmdct(coef,fs); plotwmdct(coef,fs,dynrange);

PODD Odd part of periodic function Usage: fe=podd(f); fe=podd(f,dim);

PRECT Periodic rectangle Usage: f=prect(L,n);

PROJKERN Projection onto generating kernel space Usage: cout=projkern(cin,a); cout=projkern(cin,g,a); cout=projkern(cin,ga,gs,a);

PSECH Sampled, periodized hyperbolic secant Usage: g=psech(L); g=psech(L,tfr); g=psech(L,s,'samples); [g,tfr]=psech( ...

PSINC Periodic Sinc function (Dirichlet function) Usage: f=psinc(L,n);

PTPFUN Sampled, periodized totally positive function of finite type Usage: g=ptpfun(L,w) g=ptpfun(L,w,width)

PTPFUNDUAL Sampled, periodized dual TP function of finite type Usage: gd=ptpfundual(w,a,M,L) gd=ptpfundual({w,width},a,M,L) gd=ptpfundual(...,inc) [gd,nlen]=ptpfundual

PXCORR Periodic cross correlation Usage: h=pxcorr(f,g)

QAM4 Quadrature amplitude modulation of order 4 Usage: xo=qam4(xi);

QUADTFDIST Quadratic time-frequency distribution Usage p = quadtfdist(f, q);

RAMPDOWN Falling ramp function Usage: outsig=rampdown(siglen);

RAMPSIGNAL Ramp signal Usage: outsig=rampsignal(insig,L);

RAMPUP Rising ramp function Usage: outsig=rampup(L);

RANGECOMPRESS Compress the dynamic range of a signal Usage: [outsig, sigweight] = rangecompress(insig,mu);

RANGEEXPAND Expand the dynamic range of a signal Usage: sig = rangeexpand(insig,mu,sigweight);

RECT2WIL Inverse of WIL2RECT Usage: c=rect2wil(c);

RESGRAM Reassigned spectrogram plot Usage: resgram(f,op1,op2, ...

RGB2JPEG Coverts from RGB format to the YCbCr format used by JPEG Usage: YCbCr = rgb2jpeg(RGB);

RMS RMS value of signal Usage: y = rms(f); y = rms(f,...);

S0NORM S0-norm of signal Usage: y = s0norm(f); y = s0norm(f,...);

SCALARDISTRIBUTE Copy scalar to array shape for parameter handling Usage: [...] = scalardistribute(...);

SEMIAUDPLOT 2D plot on auditory scale Usage: h=semiaudplot(x,y);

SGRAM Spectrogram Usage: sgram(f,op1,op2, ...

SHAH Discrete Shah-distribution Usage: f=shah(L,a);

SHEARFIND Shears for transformation of a general lattice to separable Usage: [s0,s1,br] = shearfind(L,a,M,lt);

SPREADADJ Symbol of adjoint spreading function Usage: cadj=spreadadj(c);

SPREADEIGS Eigenpairs of Spreading operator Usage: h=spreadeigs(K,c);

SPREADFUN Spreading function of a matrix Usage: c=spreadfun(T);

SPREADINV Apply inverse spreading operator Usage: h=spreadinv(f,c);

SPREADOP Spreading operator Usage: h=spreadop(f,c);

SYMPHASE Change Gabor coefficients to symmetric phase Usage: c=symphase(c,a);

TCONV Twisted convolution Usage: h=tconv(f,g);

TFMAT Matrix of transform / operator Usage: F=tfmat('fourier',L); F=tfmat('dcti',L); F=tfmat('dgt',g,a,M); F=tfmat('dwilt',g,M); F=tfmat('wmdct',g,M);

TFPLOT Plot coefficient matrix on the TF plane Usage: tfplot(coef,step,yr); tfplot(coef,step,yr,...);

THRESH Coefficient thresholding Usage: x=thresh(x,lambda,...); [x,N]=thresh(x,lambda,...);

TRAINDOPPLER Load the 'traindoppler' test signal Usage: s=traindoppler;

TRANSFERFUNCTION The transferfunction of a filter Usage: H=transferfunction(g,L);

U2NONUCFMT Uniform to non-uniform filterbank coefficient format Usage: c=u2nonucfmt(cu,pk)

UFILTERBANK Apply Uniform filterbank Usage: c=ufilterbank(f,g,a);

UFWT Undecimated Fast Wavelet Transform Usage: c = ufwt(f,w,J); [c,info] = ufwt(...);

UNSDGT Uniform Non-stationary Discrete Gabor transform Usage: c=unsdgt(f,g,a,M); [c,Ls]=unsdgt(f,g,a,M);

UNSDGTREAL Uniform non-stationary Discrete Gabor transform Usage: c=unsdgtreal(f,g,a,M); [c,Ls]=unsdgtreal(f,g,a,M);

UQUANT Simulate uniform quantization Usage: x=uquant(x); x=uquant(x,nbits,xmax,...);

UWFBT Undecimated Wavelet FilterBank Tree Usage: c=uwfbt(f,wt); [c,info]=uwfbt(...);

UWFBTBOUNDS Frame bounds of Undecimated WFBT Usage: fcond=uwfbtbounds(wt,L); [A,B]=uwfbtbounds(wt,L); [...]=uwfbtbounds(wt);

UWPFBT Undecimated Wavelet Packet FilterBank Tree Usage: c=uwpfbt(f,wt); [c,info]=uwpfbt(...);

UWPFBTBOUNDS Frame bounds of Undecimated WPFBT Usage: fcond=uwpfbtbounds(wt,L); [A,B]=uwpfbtbounds(wt,L);

WARPEDBLFILTER Construct a warped band-limited filter Usage: g=warpedblfilter(winname,fsupp,fc,fs,freqtoscale,scaletofreq);

WARPEDFILTERS Frequency-warped band-limited filters Usage: [g,a,fc]=warpedfilters(freqtoscale,scaletofreq,fs,fmin,fmax,bins,Ls);

WAVCELL2PACK Changes wavelet coefficients storing format Usage: [cvec,Lc] = wavcell2pack(ccell); [cvec,Lc] = wavcell2pack(ccell,dim);

WAVFUN Wavelet Function Usage: [w,s,xvals] = wavfun(g) [w,s,xvals] = wavfun(g,N)

WAVPACK2CELL Changes wavelet coefficients storing format Usage: ccell = wavpack2cell(cvec,Lc); ccell = wavpack2cell(cvec,Lc,dim);

WFBT Wavelet FilterBank Tree Usage: c=wfbt(f,wt); c=wfbt(f,wt,ext); [c,info]=wfbt(...);

WFBT2FILTERBANK WFBT equivalent non-iterated filterbank Usage: [g,a] = wfbt2filterbank(wt)

WFBTBOUNDS Frame bounds of WFBT Usage: fcond=wfbtbounds(wt,L); [A,B]=wfbtbounds(wt,L); [...]=wfbtbounds(wt);

WFBTCLENGTH WFBT subband lengths from a signal length Usage: Lc=wfbtclength(Ls,wt); [Lc,L]=wfbtclength(...);

WFBTINIT Initialize Filterbank Tree Usage: wt = wfbtinit(wtdef);

WFBTLENGTH WFBT length from signal Usage: L=wfbtlength(Ls,wt);

WFBTPUT Put node to the filterbank tree Usage: wt = wfbtput(d,k,w,wt); wt = wfbtput(d,k,w,wt,'force');

WFBTREMOVE Remove node(s) from the filterbank tree Usage: wt = wbftremove(d,kk,wt); wt = wfbtremove(d,kk,wt,'force');

WFILT_ALGMBAND An ALGebraic construction of orthonormal M-BAND wavelets with perfect reconstruction Usage: [h,g,a] = wfilt_algmband(K);

WFILT_CMBAND Generates M-Band cosine modulated wavelet filters Usage: [h,g,a] = wfilt_cmband(M);

WFILT_COIF Coiflets

WFILT_DB Daubechies FIR filterbank Usage: [h,g] = wfilt_db(N);

WFILT_DDEN Double-DENsity DWT filters (tight frame) Usage: [h,g,a] = wfilt_dden(N);

WFILT_DDENA Double-Density Dual-Tree DWT filters

WFILT_DDENB Double-Density Dual-Tree DWT filters

WFILT_DGRID Dense GRID framelets (tight frame, symmetric) Usage: [h,g,a] = wfilt_dgrid(N);

WFILT_HDEN Higher DENsity dwt filters (tight frame, frame) Usage: [h,g,a] = wfilt_hden(K);

WFILT_LEMARIE Battle and Lemarie filters Usage: [h,g,a]=wfilt_lemarie(N)

WFILT_MATLABWRAPPER Wrapper of the Matlab Wavelet Toolbox wfilters function Usage: [h,g,a] = wfilt_matlabwrapper(wname);

WFILT_MBAND Generates 4-band coder Usage: [h,g,a] = wfilt_mband(N);

WFILT_ODDEVENA Kingsbury's symmetric even filters

WFILT_ODDEVENB Kingsbury's symmetric odd filters

WFILT_OPTSYMA Optimizatized Symmetric Self-Hilbertian Filters

WFILT_OPTSYMB Optimizatized Symmetric Self-Hilbertian Filters

WFILT_QSHIFTA Improved Orthogonality and Symmetry properties

WFILT_QSHIFTB Improved Orthogonality and Symmetry properties

WFILT_REMEZ Filters designed using Remez exchange algorithm Usage: [h,g,a]=wfilt_remez(L,K,B)

WFILT_SPLINE Biorthogonal spline wavelets Usage: [h,g,a]=wfilt_spline(m,n);

WFILT_SYM Symlet filters Usage: [h,g,a]=wfilt_sym(N);

WFILT_SYMDDEN Symmetric Double-Density DWT filters (tight frame) Usage: [h,g,a] = wfilt_symdden(K);

WFILT_SYMDS Symmetric wavelets dyadic sibling Usage: [h,g,a] = wfilt_symds(K);

WFILT_SYMORTH Symmetric nearly-orthogonal and orthogonal nearly-symmetric

WFILT_SYMTIGHT Symmetric Nearly Shift-Invariant Tight Frame Wavelets

WFILTDT_DDEN Double-Density Dual-Tree DWT filters

WFILTDT_ODDEVEN Kingsbury's symmetric odd and even filters

WFILTDT_OPTSYM Optimizatized Symmetric Self-Hilbertian Filters

WFILTDT_QSHIFT Improved Orthogonality and Symmetry properties

WFILTDTINFO Plots dual-tree filters info Usage: wfiltdtinfo(dw);

WFILTINFO Plots filters info Usage: wfiltinfo(w);

WIGNERVILLEDIST Wigner-Ville distribution Usage: W = wignervilledist(f); W = wignervilledist(f, g);

WIL2RECT Arrange Wilson coefficients in a rectangular layout Usage: c=wil2rect(c);

WILBOUNDS Calculate frame bounds of Wilson basis Usage: [AF,BF]=wilbounds(g,M) [AF,BF]=wilbounds(g,M,L)

WILDUAL Wilson dual window Usage: gamma=wildual(g,M); gamma=wildual(g,M,L);

WILFRAMEDIAG Diagonal of Wilson and WMDCT frame operator Usage: d=wilframediag(g,M,L);

WILORTH Wilson orthonormal window Usage: gt=wilorth(M,L); gt=wilorth(g,M); gt=wilorth(g,M,L);

WILWIN Compute a Wilson/WMDCT window from text or cell array Usage: [g,info] = wilwin(g,M,L);

WMDCT Windowed MDCT transform Usage: c=wmdct(f,g,M); c=wmdct(f,g,M,L); [c,Ls]=wmdct(...);

WMDCT2 2D Discrete windowed MDCT transform Usage: c=wmdct2(f,g,M); c=wmdct2(f,g1,g2,[M1,M2]); c=wmdct2(f,g1,g2,[M1,M2],[L1,L2]); [c,L]=wmdct2(f,g1,g2,[M1,M2],[L1,L2])

WPBEST Best Tree selection Usage: c = wpbest(f,w,J,cost); [c,info] = wpbest(...);

WPFBT Wavelet Packet FilterBank Tree Usage: c=wpfbt(f,wt); [c,info]=wpfbt(...);

WPFBT2FILTERBANK WPFBT equivalent non-iterated filterbank Usage: [g,a] = wpfbt2filterbank(wt)

WPFBTBOUNDS Frame bounds of WPFBT Usage: fcond=wpfbtbounds(wt,L); [A,B]=wpfbtbounds(wt,L); [...]=wpfbtbounds(wt);

WPFBTCLENGTH WPFBT subband length from a signal length Usage: Lc=wpfbtclength(Ls,wt); [Lc,L]=wpfbtclength(Ls,wt);

ZAK Zak transform Usage: c=zak(f,a);

Calculates the great circle azimuth from a point 1 to a point 2.

Converts angles input in degrees to the equivalent in radians.

Convert decimal degrees to its degrees and minutes components.

Convert decimal degrees to its degrees, minutes, and seconds components.

Converts angles input in degrees to the equivalent in radians.

Calculates the great circle distance DIST between PT1 and PT2 and optionally the azimuth AZ.

Convert degrees, minutes, and seconds components into decimal degrees.

Convert degrees, and minutes components into decimal degrees.

Extract field values from struct array.

Convert angles from radians.

Convert angles from radians.

Get raster data and info or (optionally) just info from a GIS raster file.

Plot a mapstruct created by shaperead.

Convert distance to angle.

Convert kilometers into nautical miles.

Converts distance to angle by dividing distance by radius.

Convert kilometers into U.S.

Create a symbol specification structure for use with mapshow.

Draw a map based on raster or shapefile data.

Converts distance to angle by dividing distance by radius.

Convert nautical miles into kilometers.

Converts distance to angle by dividing distance by radius.

Convert nautical miles into U.S.

Converts angles input in radians to the equivalent in degrees.

Converts angle to distance by multiplying angle with radius.

Converts angles input in radians to the equivalent in degrees.

Draw a GIS raster map.

Return various info about a GIS raster file: a.o., file type, bit depth, raster size, projection and geotransformation.

Read a GIS raster file

Compute the coordinates of the end-point of a displacement on a sphere.

Remove groups of NaN and leave a single separator.

Round to multiples of 10.

Plot contents of a shapefile, a map-/geostruct or a struct made by shaperead.m.

Returns a struct with info on shapefile FNAME.

Read an ArcGis shapefile set (shp, shx and dbf).

Write contents of map- or geostruct to a GIS shape file.

Converts distance to angle by dividing distance by radius.

Convert U.S.

Convert U.S.

Converts distance to angle by dividing distance by radius.

Convert angles into degrees.

Convert angles into radians.

Return ratio for conversion between units.

Check validity and standardize unit of length.

Wraps X into the [-180 to 180] interval.

Wraps x into the [0 to 2pi] interval

Wraps X into the [0 to 360] interval.

Wraps X into the [-pi to pi] interval

Print ASCII table.

Return a one-dimensional cell array, extending along dimension DIM, which contains the slices of cell array C vertical to dimension DIM.

Compute the coefficients of the Chebyshev polynomial, given the ORDER.

Clip X values outside the range.to the value at the boundary of the range.

Displays a color board corresponding to a numeric matrix M.

Creates a latex file from a csv file.

Runs the Conways' game of life from a given initial state for a given number of generations and visualizes the process.

Compute the coefficients of the Hermite polynomial, given the ORDER.

Creates an iteration of the Hilbert space-filling curve with N points.

Generate TeXinfo skeleton documentation of PROTOTYPE.

Compute the coefficients of the Laguerre polynomial, given the ORDER.

Compute the coefficients of the Legendre polynomial, given the ORDER.

match is filter, like Lisp's ( & numerous other language's ) function for Python has a built-in filter function which takes two arguments, a function and a list, and returns a list.

Normalize the columns of a matrix to a length of 1 and return the matrix.

Normalize the rows of a matrix to a length of 1 and return the matrix.

Extract nonzero elements of X.

Calculate integer partition count.

Calculate all integer partitions.

Creates an iteration of the Peano space-filling curve with N points.

Get physical constant ARG.

Produces latex reports from scripts.

The function read_options parses arguments to a function as, [ops,nread] = read_options (args,...) - Read options

Implements the 'reduce' operator like in Lisp, or Python.

Returns N random numbers from the 1:6 range, displaying a visual selection effect.

Return M unique random integer values from 0..N-1, sorted in ascending order.

slurp_file return a whole text file F as a string S.

Solves a classical 9x9 sudoku.

Display text-based waitbar/progress bar.

Save MATRIX in LaTeX format (tabular or array).

Truncates X to ORDER of magnitude.

Return the conversion factor from FROMUNIT to TOUNIT measurements.

Creates an iteration of the Z-order space-filling curve with N points.

Returns zagzig walk-off of the elements of MTRX.

Returns zigzag walk-off of the elements of MTRX.

Block processes in the communicator COMM untill the call to this routine has been reached by all.

Return COMM the MPI_Communicator object whose description is DESCRIPTION, as a string.

Return DESCRIPTION string description of the MPI_Communicator COMM.

Return the rank of the calling process in the specified communicator.

Return the size of a communicator.

Terminate the MPI execution environment.

Indicates whether MPI_Finalize has been executed.

Get the name of the processor that is using MPI.

Initialize the MPI execution environment.

Indicates whether MPI_Init has been executed.

Nonblocking test for an MPI message.

Blocking test for a message.

Receive an MPI message containing an Octave variable and extract its value.

Transmit an Octave variable as a set of MPI message.

Classical MPI example that computes PI by integrating arctan'(x) in [0,1].

This function demonstrates sending and receiving of a 2-dimensional matrix over MPI.

This function demonstrates sending and receiving a string message over MPI.

This function demonstrates sending and receiving a sparse matrix over MPI.

This function demonstrates sending and receiving a struct over MPI.

This function demonstrates sending and receiving a string message over MPI.

Demonstrates doing Monte Carlo with mpi.

Generate a specified number of replications of a function's output and write them to a user-specified output file.

Displace the boundary of a 2D mesh setting a spring with force/length constant K along each edge and enforcing equilibrium.

Apply a baricentric regularization to equalize the size of triangle edges, i.e.

Compute MESH geometrical properties identified by input strings.

Construct an unstructured triangular 2D mesh making use of the free software gmsh.

See also: msh3m_gmsh_write.

Equalize the size of triangle edges setting a spring of rest length FACTOR*AREA along each edge of the mesh and solving for static equilibrium.

Join the two structured meshes MESH1 and MESH2 into one single mesh.

Generate a structured mesh in a thin layer of size SIGMA sitting on a natural Catmull-Rom type cubic spline with control points XC, YC.

Return a list of MESH nodes lying on the sides specified in SIDELIST.

Construct a structured triangular 2D mesh on a rectangular domain.

Extract the subdomain(s) in SDL from IMESH.

Compute MESH topological properties identified by input strings.

Plot MESH with the line specification in LINESPEC using `triplot'.

Extract the plane surface NSRF delimited by NSIDES from MESH.

Compute MESH geometrical properties identified by input strings.

Construct an unstructured tetrahedral 3D mesh making use of the free software gmsh.

See also: msh2m_gmsh_write.

Join the two structured meshes MESH1 and MESH2 into one single mesh.

Return a list of MESH nodes lying on the faces specified in FACELIST.

Construct a structured tetrahedral 3D mesh on a parallelepipedal domain.

Extract the subdomain(s) in SDL from IMESH.

Read a mesh from a dolfin .xml.gz file.

Write a mesh to a dolfin .xml file.

Refine a mesh * The MESH is a PDE-tool like structures with matrix field (p,e,t).

MVN_BREGMANCENTROID_GEODESIC Computes an arbitrary weighted KL centroid on the geodesic linking between two sided centroids c1 and c2.

MVN_BREGMANCENTROID_KL_LEFT Compute the left sided Kullback-Leibler (KL) centroid given mvn models.

MVN_BREGMANCENTROID_RIGHT Compute the right centroid given mvn models ("center of mass").

MVN_BREGMANCENTROID_SKL Compute the symmetric Kullback-Leibler (KL) centroid given mvn models.

MVN_DIV_BC Compute the Bhattacharyya coefficient between two multivariate normals.

MVN_DIV_JS Compute the Jensen-Shannon (JS) divergence between two multivariate normals.

MVN_DIV_KL Compute the Kullback-Leibler (KL) divergence.

MVN_DIV_SKL Compute the symmetric Kullback-Leibler (KL) divergence.

MVN_DIVMAT Compute a distance/divergence matrix using the specified MODELS and the given divergence T.

MVN_ENTROPY Compute the Entropy of the given multivariate normal.

MVN_FN2CLASS

MVN_ISMETRIC Analyzes the distance matrix D and returns the percentage of triples fulfilling the triangle inequality.

MVN_KMEANS Compute K-Means clustering on the given mvn models in respect to the given divergence.

MVN_KNNCLASS

MVN_NEW Initialize a mvn struct

MVN_SOM_SKL Computes a NxN SOM using the MVN models and the Symmetric Kullback-Leibler divergence.

MVN_TEST Load a testcollection and prepare for using with the mvn functions.

MVN_TRACEPROD Compute Matrix trace of the matrix product of two symmetric matrices a and b.

MVN_VERSION

BLAND_ALTMANN shows the Bland-Altman plot of two columns of measurements and computes several summary results.

CAT2BIN converts categorial into binary data each category of each column in D is converted into a logical column B = cat2bin(C); [B,BinLabel] = cat2bin(C,Label); [B,BinLabel] = cat2

CDFPLOT plots empirical commulative distribution function

CLASSIFY classifies sample data into categories defined by the training data and its group information

COEFFICIENT_OF_VARIATION returns STD(X)/MEAN(X) cv=coefficient_of_variation(x [,DIM]) cv=std(x)/mean(x)

COR calculates the correlation matrix X and Y can contain missing values encoded with NaN.

CORRCOEF calculates the correlation matrix from pairwise correlations.

COV covariance matrix X and Y can contain missing values encoded with NaN.

COVM generates covariance matrix X and Y can contain missing values encoded with NaN.

CUMSUMSKIPNAN Cumulative sum while skiping NaN's.

decompose extended covariance matrix into mean (mu), standard deviation, the (pure) Covariance (COV), correlation (xc) matrix and the correlation coefficients R2.

DETREND removes the trend from data, NaN's are considered as missing values DETREND is fully compatible to previous Matlab and Octave DETREND with the following features added: - handles NaN's by

The use of FLAG_IMPLICIT_SIGNIFICANCE is in experimental state.

FSS - feature subset selection and feature ranking the method is motivated by the max-relevance-min-redundancy (mRMR) approach [1].

GEOMEAN calculates the geomentric mean of data elements.

GSCATTER scatter plot of groups

HARMMEAN calculates the harmonic mean of data elements.

Evaluates Histogram data [R]=hist2res(H)

KURTOSIS estimates the kurtosis

MAD estimates the Mean Absolute deviation (note that according to [1,2] this is the mean deviation; not the mean absolute deviation)

MAHAL return the Mahalanobis' D-square distance between the multivariate samples x and y, which must have the same number of components (columns), but may have a different number of observations

MEAN calculates the mean of data elements.

MEANDEV estimates the Mean deviation (note that according to [1,2] this is the mean deviation; not the mean absolute deviation)

MEANSQ calculates the mean of the squares

MEDIAN data elements, [y]=median(x [,DIM])

MOMENT estimates the p-th moment M = moment(x, p [,opt] [,DIM]) M = moment(H, p [,opt]) calculates p-th central moment from data x in dimension DIM of from Histogram H

NANCONV computes the convolution for data with missing values.

NANFFT calculates the Fourier-Transform of X for data with missing values.

NANFILTER is able to filter data with missing values encoded as NaN.

NANFILTER1UC is an adaptive filter for data with missing values encoded as NaN.

NANINSTTEST checks whether the functions from NaN-toolbox have been correctly installed.

NANSTD same as STD but ignores NaN's.

NANSUM same as SUM but ignores NaN's.

NANTEST checks several mathematical operations and a few statistical functions for their correctness related to NaN's.

NORMCDF returns normal cumulative distribtion function

NORMINV returns inverse cumulative function of the normal distribution

NORMPDF returns normal probability density

PERCENTILE calculates the percentiles of histograms and sample arrays.

QUANTILE calculates the quantiles of histograms and sample arrays.

RANGE calculates the range of Y Missing values (encoded as NaN) are ignored.

RANKCORR calculated the rank correlation coefficient.

RANKS gives the rank of each element in a vector.

RMS calculates the root mean square can deal with complex data.

SEM calculates the standard error of the mean [SE,M] = SEM(x [, DIM [,W]]) calculates the standard error (SE) in dimension DIM the default DIM is the first non-single dimension M returns

SKEWNESS estimates the skewness

SPEARMAN Spearman's rank correlation coefficient.

STATISTIC estimates various statistics at once.

STD calculates the standard deviation.

SUMSKIPNAN adds all non-NaN values.

TCDF returns student cumulative distribtion function

TEST_SC: apply statistical and SVM classifier to test data

TINV returns inverse cumulative function of the student distribution

TPDF returns student probability density

Linear Discriminant Analysis for the Small Sample Size Problem as described in Algorithm 1 of J.

Train a (statistical) classifier CC = train_sc(D,classlabel) CC = train_sc(D,classlabel,MODE) CC = train_sc(D,classlabel,MODE, W) weighting D(k,:) with weight W(k) (not all classifiers suppo

TRIMEAN yields the weighted mean of the median and the quartiles
m = TRIMEAN(y).

TTEST (paired) t-test For a sample X from a normal distribution with unknown mean and variance, perform a t-test of the null hypothesis `mean (X) == M'.

TTEST2 (unpaired) t-test For two samples x and y from normal distributions with unknown means and unknown equal variances, perform a two-sample t-test of the null hypothesis of equal m

VAR calculates the variance.

XCOVF generates cross-covariance function.

XPTOPEN read of several file formats and writing of the SAS Transport Format (*.xpt)

XVAL is used for crossvalidation

ZSCORE removes the mean and normalizes data to a variance of 1.

Decompress a file using a cache.

Create an array representing a NetCDF variable.

Create an array that represent a concatenated NetCDF variables.

Coordinates of a NetCDF variable.

Read a time variable as serial day number.

Parse netCDF time unit.

Test ncBaseArray, ncCatArray and ncArray.

Create the variable VARNAME in the file FILENAME.

display meta-data of the NetCDF file FILENAME

return information about an entire NetCDF file FILENAME (i.e.

Read the variable VARNAME from the NetCDF file FILENAME.

Return the attribute ATTNAME of the variable VARNAME in the file FILENAME.

Write array X to the the variable VARNAME in the NetCDF file FILENAME.

Defines the attribute ATTNAME of the variable VARNAME in the file FILENAME with the value VAL.

Create a NetCDF called FILENAME with the dimensions, attributes, variables and groups given by the structure SCHEMA.

Aborts all changes since the last time the dataset entered in define mode.

Close the NetCDF file with the id NCID.

Copies the attribute named OLD_NAME of the variable VARID in the data set NCID to the variable VARID_OUT in the data set NCID_OUT.

Creates the file named FILENAME in the mode MODE which can have the following values: "clobber" (overwrite existing files), "noclobber" (prevent to overwrite existing files) "64bit_offset" (use the 64

Define the dimension with the name NAME and the length LEN in the dataset NCID.

Define a group in a NetCDF file.

Defines a variable with the name NAME in the dataset NCID.

Define the chunking settings of NetCDF variable VARID.

Define the compression settings NetCDF variable VARID.

Define the fill-value settings of the NetCDF variable VARID.

Defines the checksum settings of the variable with the id VARID in the data set NCID.

Deletes the attribute named NAME of the variable VARID in the data set NCID.

Leaves define-mode of NetCDF file NCID.

Get the value of a NetCDF attribute.

Gets the default chunk cache settins in the HDF5 library.

Returns the value of a NetCDF constant called NAME.

Returns a list of all constant names.

Get the data from a NetCDF variable.

Return the number of dimension (NDIMS), the number of variables (NVARS), the number of global attributes (NGATTS) and the id of the unlimited dimension (UNLIMDIMID).

Get attribute type and length.

Return the attribute id ATTNUM of the attribute named ATTNAME of the variable VARID in the dataset NCID.

Get the name of a NetCDF attribute.

Returns the name and length of a NetCDF dimension.

Return the id of a NetCDF dimension.

Return the dimension ids defined in a NetCDF file.

Return the NetCDF format of the dataset NCID.

Return the group id based on the full group name.

Return group name in a NetCDF file.

Return full name of group in NetCDF file.

Return id of the parent group

Return all groups ids in a NetCDF file.

Returns the version of the NetCDF library.

Return group id based on its name

Return the id of all unlimited dimensions of the NetCDF file NCID.

Inquires information about a NetCDF variable.

Determines the chunking settings of NetCDF variable VARID.

Determines the compression settings NetCDF variable VARID.

Determines the fill-value settings of the NetCDF variable VARID.

Determines the checksum settings of the variable with the id VARID in the data set NCID.

Return the id of a variable based on its name.

Return all variable ids.

Opens the file named FILENAME in the mode MODE.

Defines a NetCDF attribute.

Put data in a NetCDF variable.

Enter define-mode of NetCDF file NCID.

Renames the attribute named OLD_NAME of the variable VARID in the data set NCID.

Renames the dimension with the id DIMID in the data set NCID.

Renames the variable with the id VARID in the data set NCID.

Sets the default chunk cache settins in the HDF5 library.

Sets the default format of the NetCDF library and returns the previous default format (as a numeric value).

Change the fill mode (FILLMODE) of the data set NCID.

Writes all changes to the disk and leaves the file open.

test_netcdf Test the netcdf interface

AVEKNT: compute the knot averages (Greville points) of a knot vector

BASISFUN: Basis function for B-Spline

BASISFUNDER: B-Spline Basis function derivatives.

Compute the coefficient matrix for non-uniform B-splines subdivision.

BSPDEGELEV: Degree elevate a univariate B-Spline.

BSPDERIV: B-Spline derivative.

BSPEVAL: Evaluate B-Spline at parametric points.

BSPINTERPCRV: B-Spline interpolation of a 3d curve.

BSPINTERPSURF: B-Spline surface interpolation.

BSPKNTINS: Insert knots into a B-Spline

CRVKNTREMOVE: Remove one knot from the knot-vector of a NURBS curve.

Compute control points of n-th derivatives of a B-spline curve.

CURVEDERIVEVAL: Compute the derivatives of a B-spline curve.

FINDSPAN Find the span of a B-Spline knot vector at a parametric point

KNTBRKDEGMULT: Construct an open knot vector by giving the sequence of knots, the degree and the multiplicity.

KNTBRKDEGREG: Construct an open knot vector by giving the sequence of knots, the degree and the regularity.

KNTREFINE: Refine a given knot vector by dividing each interval uniformly, maintaining the continuity in previously existing knots.

KNTUNIFORM: generate uniform open knot vectors in the reference domain.

NRB2IGES : Write a NURBS curve or surface to an IGES file.

NRB4SURF: Constructs a NURBS bilinear surface.

NRBBASISFUN: Basis functions for NURBS

NRBBASISFUNDER: NURBS basis functions derivatives

NRBCIRC: Construct a circular arc.

NRBCLAMP: Compute the knot vector and control points of the clamped curve/surface.

NRBCOONS: Construction of a Coons patch.

NRBCRVDERIVEVAL: Evaluate n-th order derivatives of a NURBS curve.

NRBCTRLPLOT: Plot a NURBS entity along with its control points.

NRBCYLIND: Construct a cylinder or cylindrical patch.

NRBDEGELEV: Elevate the degree of the NURBS curve, surface or volume.

NRBDERIV: Construct the first and second derivative representation of a NURBS curve, surface or volume.

NRBDEVAL: Evaluation of the derivative and second derivatives of NURBS curve, surface or volume.

NRBEVAL: Evaluate a NURBS at parametric points.

NRBEVAL_DER_P: Compute the derivative of a NURBS object at a given point
with respect to the coordinates of the i-th control point.

NRBEVAL_DER_W: Compute the derivatives of a NURBS object at the point u
with respect to the weight of the i-th control point.

NRBEXPORT: export NURBS geometries to a format compatible with the one used in GeoPDEs.

NRBEXTRACT: construct NURBS curves by extracting the boundaries of a NURBS surface, or NURBS surfaces by extracting the boundary of a NURBS volume.

NRBEXTRUDE: Construct a NURBS surface by extruding a NURBS curve, or
construct a NURBS volume by extruding a NURBS surface.

NRBINVERSE: compute parametric point starting from physical point by inverting the NURBS map with a Newton scheme

NRBKNTINS: Insert a single or multiple knots into a NURBS curve,
surface or volume.

NRBKNTPLOT: Plot a NURBS entity with the knots subdivision.

NRBLINE: Construct a straight line.

NRBMAK: Construct the NURBS structure given the control points
and the knots.

NRBMEASURE: Compute the distance between two given points along a NURBS curve.

NRBMODP: Modify the coordinates of specific control points of any NURBS map.

NRBMODW: Modify the weights of specific control points of any NURBS map.

NRBMULTIPATCH: construct the information for gluing conforming NURBS patches, using the same format as in GeoPDEs.

NRBNUMBASISFUN: Numbering of basis functions for NURBS

NRBPERMUTE: Rearrange the directions of a NURBS volume or surface.

NRBPLOT: Plot a NURBS curve or surface, or the boundary of a NURBS volume.

NRBRECT: Construct NURBS representation of a rectangular curve.

NRBREVERSE: Reverse the evaluation directions of a NURBS geometry.

NRBREVOLVE: Construct a NURBS surface by revolving a NURBS curve, or
construct a NURBS volume by revolving a NURBS surface.

NRBRULED: Construct a ruled surface between two NURBS curves.

NRBSQUARE: create the NURBS surface for a square.

NRBSURFDERIVEVAL: Evaluate n-th order derivatives of a NURBS surface

NRBTESTCRV: Constructs a simple test curve.

NRBTESTSRF: Constructs a simple test surface.

NRBTFORM: Apply transformation matrix to the NURBS.

NRBTRANSP: Transpose a NURBS surface, by swapping U and V directions.

NRBUNCLAMP: Compute the knot vector and control points of the unclamped curve or surface.

NUMBASISFUN: List non-zero Basis functions for B-Spline in a given knot-span

SURFDERIVCPTS: Compute control points of n-th derivatives of a NURBS surface.

SURFDERIVEVAL: Compute the derivatives of a B-spline surface.

TBASISFUN: Compute a B- or T-Spline basis function, and its derivatives, from its local knot vector.

VECANGLE: An alternative to atan, returning an arctangent in the range 0 to 2*pi.

VECCROSS: The cross product of two vectors.

VECDOT: The dot product of two vectors.

VECMAG: Magnitude of the vectors.

VECMAG2: Squared magnitude of a set of vectors.

VECNORM: Normalise the vectors.

VECROT: Transformation matrix for a rotation around the axis given by a vector.

VECROTX: Transformation matrix for a rotation around the x axis.

VECROTY: Transformation matrix for a rotation around the y axis.

VECROTZ: Transformation matrix for a rotation around the z axis.

VECSCALE: Transformation matrix for a scaling.

VECTRANS: Transformation matrix for a translation.

SBN file implementing models for capacitors.

SBN file implementing models for current sources.

SBN file implementing models for diodes.

SBN file implementing models for inductors.

SBN file implementing standard models for n-mosfets.

INTERNAL FUNCTION:

SBN file implementing standard models for p-mosfets.

SBN file implementing models for resistors.

SBN file implementing Schichman-Hodges MOSFETs model.

SBN file implementing models for voltage sources.

Cycle through the circuit description structure INSTRUCT to build the system matrices A, JAC, RES for the current step of the Newton method.

Cycle through the circuit description structure INSTRUCT to build the system matrices A, B, C for the linear and time-invariant part of the system.

Solve a non-linear system of equations using the Newton-Raphson method with damping and return the computed solution vector Y.

Compute the stationary state solution OUT of the system described by INSTRUCT.

Parse a netlist in IFF format and produce the system description structure OUTSTRUCT.

Circuit file parser that can interpret a subset of the spice file format.

Perform a transient simulation of the system described by CIRSTRUCT over the time interval T using the backward Euler algorithm.

Perform a transient simulation of the system described by CIRSTRUCT over the time interval T using 'daspk'.

Perform a transient simulation of the system described by CIRSTRUCT over the time interval T using the 'odepkg' DAE solver specified in SOLVER.

Perform a transient simulation of the system described by CIRSTRUCT over the time interval T using the theta-method with parameter THETA.

Select by name some elements of the state vector of the system described by OUTSTRUCT and plot their dynamics over the time interval T.

Listen for socket connections on port PORT, read a command and return the corresponding output to the socket.

This function performs boolean operations between two polygons using the Greiner-Hormann algorithm (http://davis.wpi.edu/~matt/courses/clipping/).

This function projects geodetic coordinates into cartesian projected coordinates in the defined cartographic projection using the PROJ.4 function pj_fwd().

This function converts cartesian tridimensional geocentric coordinates into geodetic coordinates using the PROJ.4 function pj_geocentric_to_geodetic().

This function converts geodetic coordinates into cartesian tridimensional geocentric coordinates using the PROJ.4 function pj_geodetic_to_geocentric().

This function unprojects cartesian projected coordinates (in a defined cartographic projection) into geodetic coordinates using the PROJ.4 function pj_inv().

This function transforms X/Y/Z, lon/lat/h points between two coordinate systems 1 and 2 using the PROJ.4 function pj_transform().

Solves the first order system of non-linear differential equations defined by ODEFUN with the boundary conditions defined in BCFUN.

This function file can be used to solve a set of non-stiff ordinary differential equations (non-stiff ODEs) or non-stiff differential algebraic equations (non-stiff DAEs) with the well known explicit

This function file can be used to solve a set of non-stiff delay differential equations (non-stiff DDEs) with a modified version of the well known explicit Runge-Kutta method of order (2,3).

This function can be used to solve a set of stiff ordinary differential equations with a Rosenbrock method of order (2,3).

This function file can be used to solve a set of stiff ordinary differential equations (ODEs) and stiff differential algebraic equations (DAEs).

This function file can be used to solve a set of non-stiff ordinary differential equations (non-stiff ODEs) or non-stiff differential algebraic equations (non-stiff DAEs) with the well known explicit

This function file can be used to solve a set of non-stiff delay differential equations (non-stiff DDEs) with a modified version of the well known explicit Runge-Kutta method of order (4,5).

This function file can be used to solve a set of non-stiff ordinary differential equations (non-stiff ODEs) or non-stiff differential algebraic equations (non-stiff DAEs) with the well known explicit

This function file can be used to solve a set of non-stiff delay differential equations (non-stiff DDEs) with a modified version of the well known explicit Runge-Kutta method of order (2,3).

This function file can be used to solve a set of stiff ordinary differential equations (ODEs) and stiff differential algebraic equations (DAEs).

This function file can be used to solve a set of non-stiff delay differential equations (non-stiff DDEs) with a modified version of the well known explicit Runge-Kutta method of order (7,8).

This function file can be used to solve a set of stiff ordinary differential equations (ODEs) and stiff differential algebraic equations (DAEs).

This function file can be used to solve a set of stiff implicit differential equations (IDEs).

This function file can be used to solve a set of stiff ordinary differential equations (stiff ODEs) or stiff differential algebraic equations (stiff DAEs) with the Backward Euler method.

Open the differential equations examples menu and allow the user to select a submenu of ODE, DAE, IDE or DDE examples.

If this function is called with two input arguments and the first input argument ODESTRUCT is of type structure array and the second input argument OPTION is of type string then return the option valu

This function file can be used to solve a set of stiff implicit differential equations (IDEs).

Open a new figure window and plot the first result from the variable Y that is of type double column vector over the second result from the variable Y while solving.

Open a new figure window and plot the first result from the variable Y that is of type double column vector over the second and the third result from the variable Y while solving.

OdePkg is part of the GNU Octave Repository (the Octave-Forge project).

Return the solution of the event function that is specified as the first input argument @FUN in form of a function handle.

Open the DAE examples menu and allow the user to select a demo that will be evaluated.

Open the DDE examples menu and allow the user to select a demo that will be evaluated.

Open the IDE examples menu and allow the user to select a demo that will be evaluated.

Open the ODE examples menu and allow the user to select a demo that will be evaluated.

If this function is called with one input argument of type structure array then check the field names and the field values of the OdePkg structure OLDSTRUCT and return the structure as NEWSTRUCT if no

If this function is called with four input arguments of type double scalar or column vector then return a normalized value for the minimum number of correct digits MESCD that is calculated from the so

If this function is called with four input arguments of type double scalar or column vector then return a normalized value for the minimum number of correct digits SCD that is calculated from the solu

If this function is called with two input arguments and the first input argument @SOLVER is a function handle describing an OdePkg solver and the second input argument RELTOL is a double scalar descri

If this function is called with two input arguments and the first input argument @SOLVER is a function handle describing an OdePkg solver and the second input argument RELTOL is a double scalar descri

If this function is called with two input arguments and the first input argument @SOLVER is a function handle describing an OdePkg solver and the second input argument RELTOL is a double scalar descri

Open a new figure window and plot the results from the variable Y of type column vector over time while solving.

Display the results of the set of differential equations in the Octave window while solving.

If this function is called without an input argument then return a new OdePkg options structure array that contains all the necessary fields and sets the values of all fields to default values.

Multiply Jones matrices and vectors.

Return the Jones vector for left-turn circular polarized light.

Return the Jones vector for right-turn circular polarized light.

Return intensity of light described by Jones vectors.

Return the Jones matrix for a linear diattenuator at zero rotation.

Return the Jones matrix for an ideal linear polarizer.

Return the Jones matrix for a linear retarder with long axis rotation of 0 degrees.

Return the Jones vector for horizontal linearly polarized light.

Return the Jones vector for light with linear polarization at -45 degrees.

Return the Jones vector for light with linear polarization at +45 degrees.

Return the Jones vector for vertical linearly polarized light.

Return Jones matrices, representing a non-polarizing optical element.

Return the Jones matrix for rotated Jones elements.

Return the Jones matrix for a system rotator.

Return unity Jones matrices, representing a non-polarizing optical element.

Return the Jones matrix for a linear wave plate with a phase delay given in wavelength units and long axis rotation of 0 degrees.

Return Mueller matrices for a (partial) absorber.

Check physical validity of Mueller matrix or matrices.

Return the Mueller matrix for a linear diattenuator at zero rotation.

Return the Mueller matrix for a circular retarder element.

Return Mueller matrices for a (partial) depolarizer.

Return the Mueller matrix for a homogeneous elliptic diattenuator (see references).

Return the Mueller matrix for a homogeneous elliptic retarder (see references).

Check computational validity of Mueller matrix or matrices.

Return the Mueller matrix for a linear diattenuator at zero rotation.

Return the Mueller matrix for an ideal linear polarizer.

Return the Mueller matrix for a linear retarder with long axis rotation of 0 degrees.

Return mirror Mueller matrices, representing a non-polarizing optical element.

Return the Mueller matrix for rotated Mueller elements.

Return the Mueller matrix for a system rotator.

Multiply Mueller matrices and Stokes vectors.

Return unity Mueller matrices, representing a non-polarizing optical element.

Return the Mueller matrix for a linear wave plate with a phase delay given in wavelength units and long axis rotation of 0 degrees.

Return the Stokes vector for left-turn circular polarized light.

Return the Stokes vector for right-turn circular polarized light.

Return degree of polarization of light described by Stokes vectors.

Return intensity of light described by Stokes vectors.

Check validity of Stokes vector or vectors.

Return the Stokes vector for horizontal linearly polarized light.

Return the Stokes vector for light with linear polarization at -45 degrees.

Return the Stokes vector for light with linear polarization at +45 degrees.

Return the Stokes vector for vertical linearly polarized light.

Return the Stokes vector for unpolarized light.

Return the first part of the radial zernike polynom R^m_n.

Return the cartesian zernikes up to order n (as noll's index).

Return the classic name for noll's index N or "-" (no name defined) without warning if N > 21.

Convert Noll's index J to M (Azimuthal degree) and N (Radial degree).

Return the polar zernikes up to order n (as noll's index).

general linear regression

ADSMAX Alternating directions method for direct search optimization.

battery.m: repeatedly call bfgs using a battery of start values, to attempt to find global min of a nonconvex function

bfgsmin: bfgs or limited memory bfgs minimization of function

initial values

Line minimization of f along df

c = cdiff (func,wrt,N,dfunc,stack,dx) - Code for num.

NonLinear Conjugate Gradient method to minimize function F.

[lb, idx, ridx, mv] = cpiv_bard (v, m[, incl])

Frontend for computation of statistics for fitting of values, computed by a model function, to observed values.

function prt = dcdp (f, p, dp, func[, bounds])

de_min: global optimisation using differential evolution

Calculate derivate of function F.

function prt = dfdp (x, f, p, dp, func[, bounds]) numerical partial derivatives (Jacobian) df/dp for use with leasqr --------INPUT VARIABLES--------- x=vec or matrix of indep var(used as arg to fu

function jac = dfpdp (p, func[, hook])

function jac = dfxpdp (x, p, func[, hook])

USAGE [alpha,c,rms] = expfit( deg, x1, h, y )

Find the minimum of a funtion of several variables.

m = gjp (m, k[, l])

Calculate the jacobian of a function using the complex step method.

Levenberg-Marquardt nonlinear regression.

[a,fx,nev] = line_min (f, dx, args, narg, h, nev_max) - Minimize f() along dx

Solve a linear problem.

Solve nonlinear least-squares (nonlinear data-fitting) problems min [EuclidianNorm (f(x, xdata) - ydata)] .^ 2 x

Solve the linear least squares program min 0.5 sumsq(C*x - d) x subject to A*X <= B, AEQ*X = BEQ, LB <= X <= UB.

Solve nonlinear least-squares (nonlinear data-fitting) problems min [EuclidianNorm(f(x))] .^ 2 x

MDSMAX Multidirectional search method for direct search optimization.

[x0,v,nev] = nelder_mead_min (f,args,ctl) - Nelder-Mead minimization

Nonlinear Regression.

NMSMAX Nelder-Mead simplex method for direct search optimization.

Frontend for nonlinear fitting of values, computed by a model function, to observed values.

Frontend for nonlinear minimization of a scalar objective function.

Frontend for nonlinear minimization of residuals returned by a model function.

Using X0 as a starting point find a minimum of the scalar function F.

numgradient(f, {args}, minarg)

numhessian(f, {args}, minarg)

Show optim package documentation.

Problems for testing optimizers.

ex = poly_2_ex (l, f) - Extremum of a 1-var deg-2 polynomial

[y,dy] = polyconf(p,x,s)

function [A,REF,HMAX,H,R,EQUAL] = polyfitinf(M,N,K,X,Y,EPSH,MAXIT,REF0)
Best polynomial approximation in discrete uniform norm
INPUT VARIABLES:
M : degree of the fitting polyn

Multidimensional minimization (direction-set method).

Solve the quadratic program min 0.5 x'*H*x + x'*f x subject to A*X <= B, AEQ*X = BEQ, LB <= X <= UB.

Frontend for computation of statistics for a residual-based minimization.

Rosenbrock function - used to create example obj.

samin: simulated annealing minimization of a function.

dimensionality

[x,v,niter] = feval (optim_func, "testfunc","dtestf", xinit);

[xlev,vlev,nlev] = feval(optim_func, "ff", "dff", xinit) ;

[xlev,vlev,nlev] = feval (optim_func, "ff", "dff", xinit, "extra", extra) ; [xlev,vlev,nlev] = feval \ (optim_func, "ff", "dff", list (xinit, obsmat, obses));

Plain run, just to make sure ###################################### Minimum wrt 'x' is y0 [xlev,vlev,nlev] = feval (optim_func, "ff", "dff", {x0,y0,1}); ctl.df = "dff";

Use vanilla nelder_mead_min

Test using volume #################################################

x y dy

A variant of 'fzero'.

Return the coefficients of a polynomial P(X) of degree N that minimizes 'sumsq (p(x(i)) - y(i))', to best fit the data in the least squares sense.

[ret1, ret2] = wrap_f_dfdp (f, dfdp, varargin)

[x,s] = wsolve(A,y,dy)

Example program of the optimal interpolation toolbox

Performs an N-dimensional optimal interpolation.

Performs a local 1D-optimal interpolation (objective analysis).

Performs a local 2D-optimal interpolation (objective analysis).

Performs a local 3D-optimal interpolation (objective analysis).

Performs a local 4D-optimal interpolation (objective analysis).

Performs a local nD-optimal interpolation (objective analysis).

Install named variables at remote machines.

Evaluates function FUN in a parallel cluster and collects results.

Evaluates function FUN in a parallel cluster and collects results.

Return an informational structure-array with one entry for each machine specified by CONNECTIONS.

Set the property named by KEY to the value VAL for each machine specified by CONNECTIONS.

Prompts for a password (press enter for a random password) and writes TLS-SRP authentication files into the directory given by:

Evaluates a function for corresponding elements of an array.

Evaluates a function for multiple argument sets using multiple processes.

Connects to a network of parallel cluster servers.

Receive a data value from the parallel cluster machine specified by SINGLE_CONNECTION.

Send the value in variable VALUE to all parallel cluster machines specified by CONNECTIONS.

This function starts a server of the parallel cluster and should be called once at any server machine.

Evaluate COMMANDS at all remote hosts specified by CONNECTIONS.

Evaluate a function at a remote machine.

Close the parallel cluster network to which CONNECTIONS belongs.

Calls Unix 'select', see the respective manual.

Calls Unix 'select' for data connections in a parallel cluster.

Extract vector/angle form of a unit quaternion Q.

Create x-component of a quaternion's vector part.

Create y-component of a quaternion's vector part.

Create z-component of a quaternion's vector part.

Constructor for quaternions - create or convert to quaternion.

Create unit quaternion Q which describes a rotation of ANGLE radians about the vector AXIS.

Convert 3x3 rotation matrix R to unit quaternion Q.

Compute stationary or transient state occupancy probabilities for a continuous-time Markov chain.

Returns the infinitesimal generator matrix Q for a continuous birth-death process over the state space {1, 2, ..., N}.

If Q is a valid infinitesimal generator matrix, return the size (number of rows or columns) of Q.

With three arguments, compute the expected times 'L(i)' spent in each state i during the time interval [0,t], assuming that the initial occupancy vector is P.

Compute mean first passage times for an irreducible continuous-time Markov chain.

Compute the Mean-Time to Absorption (MTTA) of the CTMC described by the infinitesimal generator matrix Q, starting from initial occupancy probabilities P.

Compute the _time-averaged sojourn time_ 'M(i)', defined as the fraction of the time interval [0,t] (or until absorption) spent in state i, assuming that the state occupancy probabilities at time 0 ar

Compute stationary or transient state occupancy probabilities for a discrete-time Markov chain.

Returns the transition probability matrix P for a discrete birth-death process over state space 1, 2, ..., N.

Check whether P is a valid transition probability matrix.

Compute the expected number of visits to each state during the first N transitions, or until abrosption.

Compute mean first passage times and mean recurrence times for an irreducible discrete-time Markov chain over the state space {, 1, ..., N}.

Compute the expected number of steps before absorption for a DTMC with state space {1, 2, ...

Compute the _time-averaged sojourn times_ 'M(i)', defined as the fraction of time spent in state i during the first steps {0, 1, ..., n} (or until absorption), assuming that the state occupancy probab

Compute the Engset blocking probability P_b(A, m, n) for a system with a finite population of n users, m identical servers, no queue, individual service rate \mu, individual arrival rate \lambda (i.e.

Compute the value of the Erlang-B formula E_B(A, m) giving the probability that an open system with m identical servers, arrival rate \lambda, individual service rate \mu and offered load A = \lambda

Compute the steady-state probability E_C(A, m) that an open queueing system with m identical servers, infinite wating space, arrival rate \lambda, individual service rate \mu and offered load A = \lam

This function computes steady-state performance measures of closed queueing networks using the Mean Value Analysis (MVA) algorithm.

Compute Asymptotic Bounds for closed, multiclass networks with K service centers and C customer classes.

Compute Balanced System Bounds for closed, multiclass networks with K service centers and C customer classes.

Composite Bound (CB) on throughput and response time for closed multiclass networks.

Compute steady-state performance measures for closed, multiclass queueing networks using the Mean Value Analysys (MVA) algorithm.

Approximate Mean Value Analysis (MVA) for closed, multiclass queueing networks with K service centers and C customer classes.

Return the set of population mixes for a closed multiclass queueing network with exactly K customers.

Compute the average number of visits to the service centers of a closed multiclass network with K service centers and C customer classes.

Compute Asymptotic Bounds for the system throughput and response time of closed, single-class networks with K service centers.

Compute Balanced System Bounds on system throughput and response time for closed, single-class networks with K service centers.

Conditional MVA (CMVA) algorithm, a numerically stable variant of MVA.

Analyze product-form, single class closed networks with K service centers using the convolution algorithm.

Convolution algorithm for product-form, single-class closed queueing networks with K general load-dependent service centers.

Compute Geometric Bounds (GB) on system throughput, system response time and server queue lenghts for closed, single-class networks with K service centers and N requests.

Analyze closed, single class queueing networks using the exact Mean Value Analysis (MVA) algorithm.

Analyze closed, single class queueing networks using the Approximate Mean Value Analysis (MVA) algorithm.

Approximate MVA algorithm for closed queueing networks with blocking.

Mean Value Analysis algorithm for closed, single class queueing networks with K service centers and load-dependent service times.

Compute PB Bounds (C.

Compute the mean number of visits to the service centers of a single class, closed network with K service centers.

Compute utilization, response time, average queue length and throughput for open or closed queueing networks with finite capacity.

Mean Value Analysis for mixed queueing networks.

Creates a node; this function can be used together with 'qnsolve'.

Exact analysis of open, multiple-class BCMP networks.

Compute Asymptotic Bounds for open, multiclass networks with K service centers and C customer classes.

Compute the visit ratios to the service centers of an open multiclass network with K service centers and C customer classes.

Compute utilization, response time, average number of requests in the system, and throughput for open queueing networks.

Analyze open, single class BCMP queueing networks with K service centers.

Compute Asymptotic Bounds for open, single-class networks with K service centers.

Compute Balanced System Bounds for single-class, open networks with K service centers.

High-level function for analyzing QN models.

Compute _approximate_ utilization, response time, average number of requests in service and throughput for an asymmetric M/M/m queue.

Compute utilization, response time, average number of requests and throughput for a M/G/1 system.

Compute utilization, response time, average number of requests and throughput for a M/H_m/1 system.

Compute utilization, response time, average number of requests and throughput for a M/M/1 queue.

Compute utilization, response time, average number of requests and throughput for a M/M/1/K finite capacity system.

Compute utilization, response time, average number of requests and throughput for a M/M/\infty queue.

Compute utilization, response time, average number of requests in service and throughput for a M/M/m queue, a queueing system with m identical servers connected to a single FCFS queue.

Compute utilization, response time, average number of requests and throughput for a M/M/m/K finite capacity system.

Solve the scaled stationary bipolar DD equation system using Gummel algorithm.

Solve the scaled stationary bipolar DD equation system using Newton's method.

Solve the non-linear Poisson problem using Newton's algorithm.

some useful physical constants

material properties for silicon and silicon dioxide

n=DDGelectron_driftdiffusion(mesh,Dsides,nin,pin,V,un,tn,tp,n0,p0,weight)

function [odata,it,res] = DDGOXTgummelmap (imesh,Dsides,.

p=DDGhole_driftdiffusion(mesh,Dsides,nin,pin,V,un,tn,tp,n0,p0,weight)

[current,divrg]=DDGOXddcurrent(mesh,Sinodes,data,contacts);

n=DDGelectron_driftdiffusion(mesh,Dsides,nin,pin,V,un,tn,tp,n0,p0) IN: v = electric potential mesh = integration domain ng = initial guess and BCs for electron density p

[odata,it,res] = DDGOXgummelmap (imesh,Dsides,.

p=DDGhole_driftdiffusion(mesh,Dsides,nin,pin,V,up,tn,tp,n0,p0) IN: v = electric potential mesh = integration domain nin = initial guess and BCs for electron density pin =

[V,n,p,res,niter] = DDGOXnlpoisson (mesh,Dsides,Sinodes,Vin,nin,pin,.

DDGOXplotresults(mesh,Simesh,n,p,V,Fn,Fp,gi,nrm,step);

w = QDDGOXcompdens(mesh,Dsides,win,vin,fermiin,d2,toll,maxit,verbose);

[current,divrg]=QDDGOXddcurrent(mesh,Sinodes,data,contacts);

[odata,it,res] = QDDGOXgummelmap (imesh,Dsides,.

[V,n,p,res,niter] = QDDGOXnlpoisson (mesh,Dsides,Sinodes,SiDnodes,.

[current,divrg]=DDGOXddcurrent(Simesh,Sinodes,data,contacts);

n=ThDDGOXelectron_driftdiffusion(mesh,Dnodes,n,pin,V,Tn,un0,un1,tn,tp,n0,p0)

function [odata,nrm]=ThDDGOXeletiteration(imesh,Dsides,.

[odata,it,res] = ThDDGOXgummelmap (imesh,Dsides,.

p=ThDDGOXhole_driftdiffusion(mesh,Dnodes,nin,p,V,Tp,monp0,mobp1,tn,tp,n0,p0)

[V,n,p,res,niter] = DDGOXnlpoisson (mesh,Dsides,Sinodes,Vin,nin,pin,.

[thermdata,innrm] = ThDDGOXthermaliteration(imesh,Dsides,.

Tn = ThDDGOXupdateelectron_temp(mesh,Dnodes,Tn,n,p,Tl,Jn,E,mobn,.

Tp = ThDDGOXupdatehole_temp(mesh,Dnodes,Tp,n,p,Tl,Jp,E,mobp0,.

Tl = ThDDGOXupdatelattice_temp(mesh,Dnodes,Tl,Tn,Tp,n,p,.

UDXappend2Ddata(filename,p,t,u,attr_name,attr_rank,attr_shape)

UDXoutput2Ddata(filename,p,t,u,attr_name,attr_rank,attr_shape,endfile)

UDXoutput2Dtimeseries(filename,p,t,u,attr_name,attr_rank,attr_shape,time)

prcomputes cycling pattern for RRE extrapolation:

[bp,bn]=Ubern(x) computes Bernoulli function B(x)=x/(exp(x)-1) corresponding to to input values Z and -Z, recalling that B(-Z)=Z+B(Z)

function r=columns(m)

L = Ucompconst (mesh,coeffn,coeffe) Builds the FEM vector for the the discretization of the RHS

L = Ucomplap (mesh,coeff) Builds the FEM matrix for the the discretization of the - Laplacian

Bmat = Ucompmass2 (imesh,Bvect,Cvect);

[odata,omesh] = Udescaling(imesh,idata);

Udopdepmob (mu,par,D);

Udrawedge(mesh);

mob = Ufielddepmob(imesh,u0,F,vsat,b) Computes field dependent mobility

c=Udriftdiffusion(mesh,Dsides,guess,M,U,V,u) solves the drift diffusion equation $ -div ( u ( \nabla n - n \nabla V)) + M = U $

c=Udriftdiffusion(mesh,Dsides,guess,M,U,V,Vth,u) solves the drift diffusion equation $ -div ( u ( \nabla (n Vth) - n \nabla V)) + M = U $

mob = Ufielddepmob(imesh,u0,F,vsat,b) Computes field dependent mobility

[jx,jy]=Udrawcurrent(omesh,n,psi,psith,coeffe);

[jx,jy]=Udrawcurrent2(omesh,n,psi,psith,coeffe);

Builds the Scharfetter-Gummel approximation of the vector field

[fd]=Uinvfermidirac(eta,par);

[mesh,data]=ise2pde3(grid_file,pref,data_file,load_data,out_file) ise2pde3 estrae dati dal formato DF-ISE di ISE a pdetool di Matlab grid_file contiene il nome del file di griglia da estrarre pre

mesh=Ujoinmeshes(mesh1,mesh2,side1,side2)

mesh=Umeshproperties(mesh) precomputes some useful mesh properties

Dnodes=Unodesonside(mesh,Dsides);

[Fx,Fy]=Updegrad(mesh,F);

Udrawedge(mesh);

Updemesh(varargin);

function r=rows(m)

s = Urrextrapolation(X) RRE vector extrapolation see Smith, Ford & Sidi SIREV 29 II 06/1987

[odata,omesh] = Uscaling(imesh,idata);

SG=Ufastscharfettergummel2(mesh,v,acoeff,bcoeff)

Builds the Scharfetter-Gummel matrix for the discretization of the LHS of the equation:

guess = Usmoothguess(mesh,new,old,Dsides);

[p,e,t]=Ustructmesh(x,y,region,sides,varargin)

[p,e,t]=Ustructmesh(x,y,region,sides)

[p,e,t]=Ustructmesh(x,y,region,sides)

[p,e,t]=Ustructmesh(x,y,region,sides)

[e,t]=Usubdomains(p,t,rcts,sidelist);

[omesh,onodes,oelements]=Usubmesh(imesh,intrfc,sdl,short)

This file is part of

PKG_ADD:# Run this only if the package is installed PKG_ADD:if (! exist (fullfile (fileparts (mfilename ("fullpath")), "inst"), "dir")) PKG_ADD: dirlist= {"Utilities","DDGOX","ThDDGOX","QDDGOX","M

[current,divrg]=DDGOXddcurrent(mesh,Sinodes,data,contacts);

[odata,it,res] = DDGOXgummelmap (imesh,Dsides,.

[V,n,p,res,niter] = DDGOXnlpoisson (mesh,Dsides,Sinodes,Vin,nin,pin,.

[odata,it,res] =.

[V,n,p,res,niter] = DDGnlpoisson (mesh,Dsides,Vin,nin,pin,Fnin,Fpin,D,l2,toll,maxit,verbose) solves $$ -\lambda^2 V'' + (n(V,Fn) - p(V,Fp) -D)$$

[odata,it,res] =.

[current,divrg] = QDDGOXddcurrent (mesh,Sinodes,data,contacts); Compute contact currents wit the QDD model.

[odata,it,res] = QDDGOXgummelmap (imesh,Dsides,.

[V,n,p,res,niter] = QDDGOXnlpoisson (mesh,Dsides,Sinodes,SiDnodes,.

[odata,omesh] = Udescaling(imesh,idata); rescale data back from non-dimensional form.

mesh=Ujoinmeshes(mesh1,mesh2,side1,side2) Join two structured 3d meshes.

function [odata,omesh] = Uscaling(imesh,idata); Convert input data to non-dimensional form.

[omesh]=Ustructmesh(x,y,z,region,sides)

[omesh,onodes,oelements]=Usubmesh(imesh,intrfc,sdl,short)

Material properties for Si and SiO2 change this script and use it to overwrite constants.

Calculate the power spectrum of the autoregressive model

Calculate coefficients of an autoregressive (AR) model of complex data X using the whitening lattice-filter method of Burg (1968).

Fit an AR (P)-model with Yule-Walker estimates.

Return the filter coefficients of a modified Bartlett-Hann window of length M.

Return bessel analog filter prototype.

Generate a Bessel filter.

Transform a s-plane filter specification into a z-plane specification.

Reorder the elements of the vector X in bit-reversed order.

Return the filter coefficients of a Blackman-Harris window of length M.

Return the filter coefficients of a Blackman-Nuttall window of length M.

Return the filter coefficients of a Bohman window of length M.

Return the filter coefficients of a rectangular window of length M.

Buffer a signal into a data frame.

Design lowpass analog Butterworth filter.

Generate a Butterworth filter.

Compute the minimum filter order of a Butterworth filter with the desired response characteristics.

Return the complex cepstrum of the vector X.

Returns the value of the nth-order Chebyshev polynomial calculated at the point x.

Design lowpass analog Chebyshev type I filter.

Compute the minimum filter order of a Chebyshev type I filter with the desired response characteristics.

Design lowpass analog Chebyshev type II filter.

Compute the minimum filter order of a Chebyshev type II filter with the desired response characteristics.

Return the filter coefficients of a Dolph-Chebyshev window of length M.

Generate a Chebyshev type I filter with RP dB of passband ripple.

Generate a Chebyshev type II filter with RS dB of stopband attenuation.

Evaluate a chirp signal at time T.

Constrained L2 bandpass FIR filter design.

Calculate boundary indexes of clusters of 1's.

Compute the Complex Morlet wavelet.

Usage: [Pxx,freq] = cohere(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)

If A is a column vector and X is a column vector of length N, then

Split the vector z into its complex (ZC) and real (ZR) elements, eliminating one of each complex-conjugate pair.

Estimate cross power spectrum of data X and Y by the Welch (1967) periodogram/FFT method.

Usage: [Pxx,freq] = csd(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)

Chirp z-transform.

Creates a vectorized function based on data samples using interpolation.

Compute the discrete cosine transform of X.

Compute the 2-D discrete cosine transform of matrix X.

Return the DCT transformation matrix of size N-by-N.

Downsample the signal X by a reduction factor of Q.

Compute the N-by-N Fourier transformation matrix.

Reorder the elements of the vector X in digit-reversed order.

Compute the dirichlet function.

Downsample the signal, selecting every Nth element.

Computes the type I discrete sine transform of X.

Discrete wavelet transform (1D).

Generate an elliptic or Cauer filter with RP dB of passband ripple and RS dB of stopband attenuation.

Design lowpass analog elliptic filter.

Compute the minimum filter order of an elliptic filter with the desired response characteristics.

Calculate the Fast Hartley Transform of real input D.

Forward and reverse filter the signal.

Set initial condition vector for filter function The vector zf has the same values that would be obtained from function filter given past inputs x and outputs y

Finds peaks on DATA.

Produce an order N FIR filter with the given frequency cutoff W, returning the N+1 filter coefficients in B.

Produce an order N FIR filter with arbitrary frequency response M over frequency bands F, returning the N+1 filter coefficients in B.

FIR filter design using least squares method.

Return the filter coefficients of a Flat Top window of length M.

Shift the series X by a (possibly fractional) number of samples D.

Compute the s-plane frequency response of the IIR filter B(s)/A(s) as H = polyval(B,j*W)./polyval(A,j*W).

Plot the amplitude and phase of the vector H.

Compute peak full-width at half maximum (FWHM) or at another level of peak maximum for vector or matrix data Y, optionally sampled as y(x).

Compute the Walsh-Hadamard transform of X using the Fast Walsh-Hadamard Transform (FWHT) algorithm.

Return the Gaussian modulated sinusoidal pulse.

Return a Gaussian convolution window of length M.

Return the filter coefficients of a Gaussian window of length M.

Return the gaussian monopulse.

Compute the group delay of a filter.

Return the filter coefficients of a Hanning window of length M.

Analytic extension of real valued signal.

Compute the inverse discrete cosine transform of X.

Compute the inverse 2-D discrete cosine transform of matrix X.

Computes the inverse type I discrete sine transform of Y.

Calculate the inverse Fast Hartley Transform of real input D.

Compute the inverse Walsh-Hadamard transform of X using the Fast Walsh-Hadamard Transform (FWHT) algorithm.

IIR Low Pass Filter to Multiband Filter Transformation

Converts analog filter with coefficients B and A to digital, conserving impulse response.

Generate impulse-response characteristics of the filter.

Upsample the signal x by a factor of q, using an order 2*q*n+1 FIR filter.

usage: [B,A] = invfreq(H,F,nB,nA) [B,A] = invfreq(H,F,nB,nA,W) [B,A] = invfreq(H,F,nB,nA,W,[],[],plane) [B,A] = invfreq(H,F,nB,nA,W,iter,tol,plane)

Usage: [B,A] = invfreqs(H,F,nB,nA) [B,A] = invfreqs(H,F,nB,nA,W) [B,A] = invfreqs(H,F,nB,nA,W,iter,tol,'trace')

usage: [B,A] = invfreqz(H,F,nB,nA) [B,A] = invfreqz(H,F,nB,nA,W) [B,A] = invfreqz(H,F,nB,nA,W,iter,tol,'trace')

Converts digital filter with coefficients B and A to analog, conserving impulse response.

Return the filter coefficients of a Kaiser window of length M.

Return the parameters needed to produce a filter of the desired specification from a Kaiser window.

Use the Durbin-Levinson algorithm to solve: toeplitz(acf(1:p)) * x = -acf(2:p+1).

Compute the generalized Marcum Q function of order M with noncentrality parameter A and argument B.

Apply a median filter of length N to the signal X.

Compute the Mexican hat wavelet.

Compute the Meyer wavelet auxiliary function.

Compute the Morlet wavelet.

Calculate moving RMS value of the signal in X.

Estimate (mean square) coherence of signals X and Y.

usage: [Zz, Zp, Zg] = ncauer(Rp, Rs, n)

Return the filter coefficients of a Blackman-Harris window defined by Nuttall of length M.

Return the filter coefficients of a Parzen window of length M.

usage: [psd,f_out] = pburg(x,poles,freq,Fs,range,method,plot_type,criterion)

Return coefficients for an IIR notch-filter with one or more filter frequencies and according (very narrow) bandwidths to be used with 'filter' or 'filtfilt'.

b = polystab(a)

Calculates the primitive of a function.

Generate the signal y=sum(func(t+d,...)) for each d.

USAGE: [spectra,freq] = pwelch(x,window,overlap,Nfft,Fs, range,plot_type,detrend,sloppy) Estimate power spectral density of data "x" by the Welch (1967) period

usage: [psd,f_out] = pyulear(x,poles,freq,Fs,range,method,plot_type)

Computes a finite impulse response (FIR) filter for use with a quasi-perfect reconstruction polyphase-network filter bank.

Produce the cepstrum of the signal x, and if desired, the minimum phase reconstruction of the signal x.

Generate a rectangular pulse over the interval [-W/2,W/2), sampled at times T.

Return the filter coefficients of a rectangular window of length M.

Parks-McClellan optimal FIR filter design.

Change the sample rate of X by a factor of P/Q.

Compute the partial fraction expansion (PFE) of filter H(z) = B(z)/A(z).

Compute the partial fraction expansion of filter H(z) = B(z)/A(z).

Calculate the x(t) reconstructed from samples x[n] sampled at a rate 1/T samples per unit time.

Generates a sawtooth wave of period '2 * pi' with limits '+1/-1' for the elements of T.

Implements a multisignal Schmitt trigger with levels LVL.

Transform band edges of a generic lowpass filter (cutoff at W=1) represented in splane zero-pole-gain form.

Computes the filter coefficients for all Savitzsky-Golay smoothing filters of order p for length n (odd).

Smooth the data in x with a Savitsky-Golay smoothing filter of polynomial order p and length n, n odd, n > p.

Compute the Complex Shannon wavelet.

Evaluate a train of sigmoid functions at T.

Convert series second-order sections to direct form H(z) = B(z)/A(z).

Convert series second-order sections to zeros, poles, and gains (pole residues).

Second order section IIR filtering of X.

Generate a spectrogram for the signal X.

Generate a square wave of period 2 pi with limits +1/-1.

Conversion from transfer function to state-space.

Converts a state space representation to a set of poles and zeros; K is a gain associated with the zeros.

Convert direct-form filter coefficients to series second-order sections.

Conversion from transfer function to state-space.

Convert transfer functions to poles-and-zero representations.

Usage: [Pxx,freq] = tfe(x,y,Nfft,Fs,window,overlap,range,plot_type,detrend)

Estimate transfer function of system with input X and output Y.

Return the filter coefficients of a triangular window of length M.

Generate a triangular pulse over the interval [-w/2,w/2), sampled at times t.

Return the filter coefficients of a Tukey window (also known as the cosine-tapered window) of length M.

Return the coefficients of an Ultraspherical window of length M.

Upsample, FIR filtering, and downsample.

Upsample the signal, inserting N-1 zeros between every element.

Upsamples a vector interleaving given values or copies of the vector elements.

1-D or 2-D convolution.

Return the filter coefficients of a Welch window of length M.

Create an M-point window from the function F.

Extract the elements of X of size L from the center, the right or the left.

Reverse the order of the element of the vector X.

Estimates the cross-correlation.

Compute the 2D cross-correlation of matrices A and B.

Compute covariance at various lags [=correlation(x-mean(x),y-mean(y))].

Estimates the points at which a given waveform y=y(x) crosses the x-axis using linear interpolation.

Convert filter poles and zeros to second-order sections.

Conversion from zero / pole to state space.

Converts zeros / poles to a transfer function.

Plot the poles and zeros.

socket constant

socket constant

socket constant

socket constant

socket constant

socket constant

socket constant

socket constant

socket constant

socket constant

socket constant

socket constant

Accept incoming connection on specified socket.

Bind specific socket to port number.

Connect socket.

Disconnect socket.

Return IP address for host name.

Listen on socket for connections.

Read data from specified socket.

Send data on specified socket.

Creates a socket.

Create or manipulate sparse matrices using the RSB format provided by librsb, as similarly as possible to `sparse'.

Average values over ranges of one variable Given X (size N*1) and Y (N*M), this function splits the range of X into up to K intervals (bins) containing approximately equal numbers of elements, and for

Returns the piecewise polynomial form of the Catmull-Rom cubic spline interpolating F at the points X.

cubic spline interpolation with various end conditions.

cubic spline interpolation

Cubic spline approximation (smoothing) approximate [X,Y], weighted by W (inverse variance of the Y values; if not given, equal weighting is assumed), at XI

Cubic spline approximation with smoothing parameter estimation Approximately interpolates [X,Y], weighted by W (inverse variance; if not given, equal weighting is assumed), at XI.

De-duplication and sorting to facilitate spline smoothing Points are sorted in ascending order of X, with each set of duplicates (values with the same X, within TOL) replaced by a weighted average.

differentiate the spline in pp-form

plots spline

r = fnval(pp,x) or r = fnval(x,pp) Compute the value of the piece-wise polynomial pp at points x.

Thin plate smoothing of scattered values in multi-D approximately interpolate [X,Y] at XI

Evaluates a thin plate spline at given points XI

Evaluates the first derivative of a thin plate spline at given points XI

Return the CDF for the given Anderson-Darling coefficient A computed from N values sampled from a distribution.

Test the hypothesis that X is selected from the given distribution using the Anderson-Darling test.

Perform a multi-way analysis of variance (ANOVA).

For each element of X, compute the cumulative distribution function (CDF) at X of the Birnbaum-Saunders distribution with parameters LOCATION, SCALE and SHAPE.

For each element of X, compute the quantile (the inverse of the CDF) at X of the Birnbaum-Saunders distribution with parameters LOCATION, SCALE, and SHAPE.

For each element of X, compute the probability density function (PDF) at X of the Birnbaum-Saunders distribution with parameters LOCATION, SCALE and SHAPE.

Return a matrix of random samples from the generalized Pareto distribution with parameters LOCATION, SCALE and SHAPE.

Compute mean and variance of the beta distribution.

Compute mean and variance of the binomial distribution.

Test for probability P of a binomial sample

Produce a box plot.

For each element of X, compute the cumulative distribution function (CDF) at X of the Burr distribution with scale parameter ALPHA and shape parameters C and K.

For each element of X, compute the quantile (the inverse of the CDF) at X of the Burr distribution with scale parameter ALPHA and shape parameters C and K.

For each element of X, compute the probability density function (PDF) at X of the Burr distribution with scale parameter ALPHA and shape parameters C and K.

Return a matrix of random samples from the generalized Pareto distribution with scale parameter ALPHA and shape parameters C and K.

Read case names from an ascii file.

Write case names to an ascii file.

Return cumulative density function of NAME function for value X.

Compute mean and variance of the chi-square distribution.

Returns confidence level of multinomial parameters estimated p = x / sum(x) with predefined confidence interval B.

Classical multidimensional scaling of a matrix.

Return all combinations of K elements in DATA.

Compute the cumulative distribution function of a copula family.

Compute the probability density function of a copula family.

Generate random samples from a copula family.

Perform cross validation on given data.

Distance covariance and correlation statistics.

Plots a dendrogram using the output of function 'linkage'.

Compute mean and variance of the exponential distribution.

Full-factor design with n binary terms.

Compute mean and variance of the F distribution.

Full factorial design.

Calculate gamma distribution parameters.

Calculates the negative log-likelihood function for the Gamma distribution over vector R, with the given parameters A and B.

Compute mean and variance of the gamma distribution.

Compute the geometric mean.

Compute mean and variance of the geometric distribution.

Compute the cumulative distribution function of the generalized extreme value (GEV) distribution.

Find the maximum likelihood estimator (PARAMHAT) of the generalized extreme value (GEV) distribution to fit DATA.

Find an estimator (PARAMHAT) of the generalized extreme value (GEV) distribution fitting DATA using the method of L-moments.

Compute a desired quantile (inverse CDF) of the generalized extreme value (GEV) distribution.

Compute the negative log-likelihood of data under the generalized extreme value (GEV) distribution with given parameter values.

Compute the probability density function of the generalized extreme value (GEV) distribution.

Return a matrix of random samples from the generalized extreme value (GEV) distribution with parameters K, SIGMA, MU.

Compute the mean and variance of the generalized extreme value (GEV) distribution.

Compute the cumulative distribution function (CDF) at X of the generalized Pareto distribution with parameters LOCATION, SCALE, and SHAPE.

For each element of X, compute the quantile (the inverse of the CDF) at X of the generalized Pareto distribution with parameters LOCATION, SCALE, and SHAPE.

Compute the probability density function (PDF) at X of the generalized Pareto distribution with parameters LOCATION, SCALE, and SHAPE.

Return a matrix of random samples from the generalized Pareto distribution with parameters LOCATION, SCALE and SHAPE.

Get index for group variables.

Compute the harmonic mean.

Produce bivariate (2D) histogram counts or plots.

Plot histogram with superimposed fitted normal density.

Estimate the matrix of transition probabilities and the matrix of output probabilities of a given sequence of outputs and states generated by a hidden Markov model.

Generate an output sequence and hidden states of a hidden Markov model.

Use the Viterbi algorithm to find the Viterbi path of a hidden Markov model given a sequence of outputs.

Compute mean and variance of the hypergeometric distribution.

Compute the probability density function of the Wishart distribution

Return a random matrix sampled from the inverse Wishart distribution with given parameters

Compute jackknife estimates of a parameter taking one or more given samples as parameters.

For each element of X, compute the cumulative distribution function (CDF) at X of the Johnson SU distribution with shape parameters ALPHA1 and ALPHA2.

For each element of X, compute the probability density function (PDF) at X of the Johnson SU distribution with shape parameters ALPHA1 and ALPHA2.

Perform a K-means clustering of the NxD table DATA.

Produce a hierarchical clustering dendrogram

Compute mean and variance of the lognormal distribution.

Compute the mean/median absolute deviation of X.

Mahalanobis' D-square distance.

Compute the probability density function of the multinomial distribution.

Generate random samples from the multinomial distribution.

Produce a smooth monotone increasing approximation to a sampled functional dependence y(x) using a kernel method (an Epanechnikov smoothing kernel is applied to y(x); this is integrated to yield the m

Compute the cumulative distribution function of the multivariate normal distribution.

Compute multivariate normal pdf for X given mean MU and covariance matrix SIGMA.

Draw N random D-dimensional vectors from a multivariate Gaussian distribution with mean MU(NxD) and covariance matrix SIGMA(DxD).

Compute the cumulative distribution function of the multivariate Student's t distribution.

Compute the probability density function of the multivariate Student's t distribution.

Generate random samples from the multivariate t-distribution.

For each element of X, compute the cumulative distribution function (CDF) at X of the Nakagami distribution with shape parameter M and scale parameter W.

For each element of X, compute the quantile (the inverse of the CDF) at X of the Nakagami distribution with shape parameter M and scale parameter W.

For each element of X, compute the probability density function (PDF) at X of the Nakagami distribution with shape parameter M and scale parameter W.

Return a matrix of random samples from the Nakagami distribution with shape parameter M and scale W.

Find the maximal element while ignoring NaN values.

Compute the mean value while ignoring NaN values.

Compute the median of data while ignoring NaN values.

Find the minimal element while ignoring NaN values.

Compute the standard deviation while ignoring NaN values.

Compute the sum while ignoring NaN values.

Compute the variance while ignoring NaN values.

Compute mean and variance of the negative binomial distribution.

Transform a set of data so as to be N(0,1) distributed according to an idea by van Albada and Robinson.

Produce normal probability plot for each column of X.

Compute mean and variance of the normal distribution.

* pcacov performs principal component analysis on the nxn covariance matrix X * COEFF : a nxn matrix with columns containing the principal component coefficients * LATENT : a vector

* X : N x P Matrix with N observations and P variables, the variables will be mean centered * NDIM : Is a scalar indicating the number of principal components to use and should be <= P

Return probability density function of NAME function for value X.

Return the distance between any two rows in X.

Compute pairwise distance between two sets of vectors.

plsregress(X, Y, NCOMP) * X: Matrix of observations * Y: Is a vector or matrix of responses * NCOMP: number of components used for modelling * X and Y will be mean centered to improve accu

Compute mean and variance of the Poisson distribution.

* princomp performs principal component analysis on a NxP data matrix X * COEFF : returns the principal component coefficients * SCORE : returns the principal component scores, the repre

Returns random deviates drawn from a q-Gaussian distribution.

Generates pseudo-random numbers from a given one-, two-, or three-parameter distribution.

Elements sampled from a vector.

Compute the cumulative distribution function of the Rayleigh distribution.

Compute the quantile of the Rayleigh distribution.

Compute the probability density function of the Rayleigh distribution.

Generate a matrix of random samples from the Rayleigh distribution.

Compute mean and variance of the Rayleigh distribution.

Multiple Linear Regression using Least Squares Fit of Y on X with the model 'y = X * beta + e'.

Linear scalar regression using gaussian processes.

Perform a repeated measures analysis of variance (Repeated ANOVA).

Runs test for detecting serial correlation in the vector X.

Test for median.

Interchange between distance matrix and distance vector formats.

Linear regression with stepwise variable selection.

Compute a frequency table.

Read tabular data from an ascii file.

Write tabular data to an ascii file.

Compute the cumulative distribution function (CDF) at X of the triangular distribution with parameters A, B, and C on the interval [A, B].

For each element of X, compute the quantile (the inverse of the CDF) at X of the triangular distribution with parameters A, B, and C on the interval [A, B].

Compute the trimmed mean.

Compute the probability density function (PDF) at X of the triangular distribution with parameters A, B, and C on the interval [A, B].

Return a matrix of random samples from the rectangular distribution with parameters A, B, and C on the interval [A, B].

Compute mean and variance of the t (Student) distribution.

Test for mean of a normal sample with known variance.

Test for mean of a normal sample with known variance.

Compute mean and variance of the discrete uniform distribution.

Compute mean and variance of the continuous uniform distribution.

Perform a F-test for equal variances.

Perform a F-test for equal variances.

Produce a Violin plot of the data X.

Evaluates the Von Mises probability density function.

Draw random angles from a Von Mises distribution with mean MU and concentration K.

Compute mean and variance of the Weibull distribution.

Compute the probability density function of the Wishart distribution

Return a random matrix sampled from the Wishart distribution with given parameters

Test for mean of a normal sample with known variance.

STK_BOUNDINGBOX constructs the bounding box for a set of points

STK_CONDITIONING produces conditioned sample paths

STK_DATASET_TWOBUMPS defines datasets based on the TwoBumps response function

STK_DISCRETECOV computes a covariance matrix for a discrete model

STK_DIST computes a matrix of (Euclidean) distances

STK_DISTRIB_NORMAL_EI computes the normal (Gaussian) expected improvement

STK_DISTRIB_STUDENT_EI computes the Student expected improvement

STK_DOMINATEHV computes the hypervolume dominated by a set of points

STK_EXAMPLE_DOE01 Examples of two-dimensional designs

STK_EXAMPLE_DOE02 "Sequential Maximin" design

STK_EXAMPLE_DOE03 A simple illustration of 1D Bayesian optimization

STK_EXAMPLE_DOE04 Probability of misclassification

STK_EXAMPLE_KB01 Ordinary kriging in 1D, with noiseless data

STK_EXAMPLE_KB01N Ordinary kriging in 1D, with noisy data

STK_EXAMPLE_KB02 Ordinary kriging in 1D with parameter estimation

STK_EXAMPLE_KB02N Noisy ordinary kriging in 1D with parameter estimation

STK_EXAMPLE_KB03 Ordinary kriging in 2D

STK_EXAMPLE_KB05 Generation of conditioned sample paths

STK_EXAMPLE_KB06 Ordinary kriging VS kriging with a linear trend

STK_EXAMPLE_KB07 Simulation of sample paths from a Matern process

STK_EXAMPLE_KB08 Generation of conditioned sample paths made easy

STK_EXAMPLE_KB09 Generation of sample paths conditioned on noisy observations

STK_EXAMPLE_KB10 Leave-one-out (LOO) cross validation

STK_EXAMPLE_MISC01 Several correlation functions from the Matern family

STK_EXAMPLE_MISC02 How to use priors on the covariance parameters

STK_EXAMPLE_MISC03 How to deal with (known) seasonality

STK_EXAMPLE_MISC04 Pareto front simulation

STK_EXPCOV_ANISO computes the anisotropic exponential covariance function

STK_EXPCOV_ISO computes the isotropic exponential covariance function

STK_FEVAL evaluates a function at given evaluation points

STK_FILLDIST computes the fill distance of a set of points

STK_GAUSSCOV_ANISO computes the anisotropic Gaussian covariance function

STK_GAUSSCOV_ISO computes the isotropic Gaussian covariance function

STK_GENERATE_SAMPLEPATHS generates sample paths of a Gaussian process

STK_INIT initializes the STK

STK_ISDOMINATED returns true for dominated rows

STK_ISNOISY returns false for noiseless models

STK_LENGTH return the "length" of an array

STK_LM_POLYNOMIAL creates a polynomial linear model object

STK_MAKE_MATCOV computes a covariance matrix (and a design matrix)

STK_MATERNCOV32_ANISO computes the anisotropic Matern covariance with nu=3/2

STK_MATERNCOV32_ISO computes the isotropic Matern covariance with nu=3/2

STK_MATERNCOV52_ANISO computes the anisotropic Matern covariance with nu=5/2

STK_MATERNCOV52_ISO computes the isotropic Matern covariance

STK_MATERNCOV_ANISO computes the anisotropic Matern covariance

STK_MATERNCOV_ISO computes the isotropic Matern covariance

STK_MAXABSCORR computes the maximal absolute correlation for a set of points

STK_MINDIST computes the separation distance of a set of points

STK_MINIMIZE_BOXCONSTRAINED performs box-constrained minimization

STK_MINIMIZE_UNCONSTRAINED performs unconstrained minimization

STK_MODEL generates a model with default covariance parameters

STK_MODEL_UPDATE updates a model with new data

STK_NOISECOV computes a noise covariance

STK_NORMALIZE normalizes a dataset to [0; 1] ^ DIM

STK_OPTIM_ISAVAILABLE checks if a given optimizer is available

STK_OPTIONS_GET returns the value of one or all STK options

STK_OPTIONS_SET sets the value of one or all STK options

STK_PARAM_ESTIM estimates the parameters of a covariance function

STK_PARAM_GLS computes a generalised least squares estimate

STK_PARAM_INIT provides a starting point for stk_param_estim

STK_PARAM_INIT_LNV provides a rough estimate of the variance of the noise

STK_PARAM_RELIK computes the restricted likelihood of a model given data

STK_PARETOFIND finds non-dominated rows in an array

STK_PHIPCRIT computes the "phi_p" criterion of Morris & Mitchell

STK_PLOT1D is a convenient plot function for 1D kriging predictions

STK_PLOT_HISTNORMRES plots an histogram for normalized residuals

STK_PLOT_PREDVSOBS plots predictions against observations

STK_PMISCLASS computes the (expected) probability of misclassification

STK_PREDICT performs a kriging prediction from data

STK_PREDICT_LEAVEONEOUT computes LOO predictions and residuals

STK_RBF_EXPONENTIAL computes the exponential correlation function

STK_RBF_GAUSS computes the Gaussian correlation function

STK_RBF_MATERN computes the Matern correlation function.

STK_RBF_MATERN32 computes the Matern correlation function of order 3/2.

STK_RBF_MATERN52 computes the Matern correlation function of order 5/2.

STK_RBF_SPHERICAL computes the spherical correlation function

STK_RESCALE rescales a dataset from one box to another

STK_RUNTESTS runs all tests in a given directory (or in STK's searchpath).

STK_SAMPCRIT_EHVI_EVAL computes the EHVI criterion

STK_SAMPCRIT_EI_EVAL computes the EI criterion

STK_SAMPCRIT_EMMI_EVAL computes the EMMI criterion

STK_SAMPLING_HALTON_RR2 generates points from the Halton/RR2 sequence

STK_SAMPLING_MAXIMINLHS generates a "maximin" LHS design

STK_SAMPLING_OLHS generates a random Orthogonal Latin Hypercube (OLH) sample

STK_SAMPLING_RANDOMLHS generates a random LHS design

STK_SAMPLING_RANDUNIF generates uniformly distributed points

STK_SAMPLING_REGULARGRID builds a regular grid

STK_SAMPLING_SOBOL generates points from a Sobol sequence

STK_SAMPLING_VDC_RR2 generates points from the "RR2" van der Corput sequence

STK_SPHCOV_ANISO computes the anisotropic spherical covariance function

STK_SPHCOV_ISO computes the isotropic spherical covariance function

STK_TESTFUN_BOREHOLE computes the "borehole model" response function

STK_TESTFUN_BRANINHOO computes the Branin-Hoo function.

STK_TESTFUN_GOLDSTEINPRICE computes the Goldstein-Price function

STK_TESTFUN_TWOBUMPS computes the TwoBumps response function

STK_VERSION returns STK's version number

Convert a base64 CODE (a string of printable characters according to RFC 2045) into the original ASCII data set of range 0-255.

Convert X into string of printable characters according to RFC 2045.

Compare strings S1 and S2 like the C function.

Compute the Levenshtein edit distance between the two strings.

Perl-compatible regular expression matching.

Return structure-array S after setting the fields FIELDS with the slices of cell-array C vertically to dimension DIM.

Returns a logical array with same dimensions as structure S, indicating where field NAME is empty.

Works similarly to 'struct2cell' (see there), but considers only fields given by the strings in cell array NAMES.

It is equivalent to [S.k1, ...] Return selected values from a scalar struct.

Sets S.KEY1 = VALUE1, S.KEY2 = VALUE2, etc, finally returning S.

Return the concatenation of N-d structures STRUCT1, ..., STRUCTN along dimension DIM.

s = tars (foo,bar, ...

Specify assumptions for a symbolic variable (replace existing).

List assumptions on symbolic variables.

Return symbolic Bernoulli numbers or Bernoulli polynomials.

Return Catalan constant.

Convert cell array to symbolic array.

Set/get number of digits used in variable precision arith.

Compute the Dirac delta (generalized) function.

Return Eulerâ€“Mascheroni constant.

Run Python code, automatically transferring results.

Return symbolic Fibonacci numbers or Fibonacci polynomials.

Return a list (cell array) of the symbols in an expression.

Return a symbolic set containing the inputs without duplicates.

Compute the Heaviside unit-step function.

Evaluate Laguerre polynomials.

Compute the Lambert W function of Z.

Run the OctSymPy tests, log results, and return true if any fail.

Create a symbolic polynomial expression from coefficients.

Run some Python command on some objects and return other objects.

Preferences for the Symbolic package.

Create symbolic variables and symbolic functions.

Create a variable-precision floating point number.

Numerical solution of a symbolic equation.

This program takes the output of d2, c2d or c1 and smooths it by averaging over a given interval.

Estimates the Renyi entropy of Qth order using a partition of the phase space instead of using the Grassberger-Procaccia scheme.

Computers curves for the fixed mass computation of information dimension (mentioned in TISEAN 3.0.1 documentation).

This program calculates the local slopes by fitting straight lines onto c1 correlation sum data (the 'c1' field of the c1 output).

This program calculates the Gaussian kernel correlation integral and its logarithmic derivatice from correlation sums calculated by d2 (the 'c2' field of the d2 output).

This program calculates the maximum likelihood estimator (the Takens' estimator) from correlation sums of the output of d2 (the 'c2' field of the d2 output) or c1 (the 'c1' field of c1 output).

This program estimates the correlation sum, the correlation dimension and the correlation entropy of a given, possibly multivariate, data set.

Produce delay vectors

Determine the effect of an end-to-end mismatch on the autocorrelation structure for various sub-sequence lengths.

Determines the fraction of false nearest neighbors.

Multivariate noise reduction using the GHKSS algorithm.

Generate Henon map

Generate Ikeda map

Performs simple nonlinear noise reduction

This program makes a local linear ansatz and estimates the one step prediction error of the model.

This function depending on whether switch 'zeroth' is set produces either a local linear ansatz or a zeroth order ansatz for a possibly multivariate time series and iterates an artificial trajectory.

Makes a local linear ansatz and estimates the one step prediction error of the model.

Estimates the maximum Lyapunov exponent using the algorithm described by Kantz on the TISEAN reference page:

Estimates the largest Lyapunov exponent of a given scalar data set using the algorithm described by Resentein et al.

Estimates the spectrum of Lyapunov exponents using the method of Sano and Sawada.

Estimates the average forecast error for a local constant (zeroth order) fit as a function of the neighborhood size.

This program fits a locally zeroth order model to a possibly multivariate time series and iterates the time series into the future.

Estimates the average forecast error for a zeroth order fit from a multidimensional time series

Estimates the time delayed mutual information of the data.

Performs a global principal component analysis (PCA).

Make a Poincare section for time continuous scalar data sets along one of the coordinates of the embedding vector.

Models the data making a polynomial ansatz.

This program models the data using a radial basis function (rbf) ansatz.

Produce delay vectors

Computes the binned autocorrelation function of a series of event times.

Computes a power spectrum assuming that the data are the times of singular events, e.g.

Generates multivariate surrogate data (implements the iterative Fourier scheme).

Calculates time reversal assymetry statistic.

Locates unstable periodic points.

Creates delay coordinates for upo output.

Takes two data sets and fits a zeroth order model of data set 1 (X1) to predict data set 2 (X2) - cross prediction.

Calculates adaptive autoregressive (AAR) and adaptive autoregressive moving average estimates (AARMA) of real-valued data series using Kalman filter algorithm.

Estimating Adaptive AutoRegressive-Moving-Average-and-mean model (includes mean term)

converts the autocorrelation sequence into an AR polynomial [A,Efinal] = ac2poly(r)

converts the autocorrelation function into reflection coefficients [RC,r0] = ac2rc(r)

Calculates autocorrelations for multiple data series.

ACOVF estimates autocovariance function (not normalized) NaN's are interpreted as missing values.

ADIM adaptive information matrix.

Adaptive Mean-AutoRegressive-Moving-Average model estimation [z,e,ESU,REV,V,Z,SPUR] = amarma(y, mode, MOP, UC, z0, Z0, V0, W);

converts autoregressive parameters into AR polymials Multiple polynomials can be converted.

converts autoregressive parameters into reflection coefficients with the Durbin-Levinson recursion for multiple channels function [AR,RC,PE] = ar2rc(AR); function [MX,PE] = ar2rc(AR);

AR_SPA decomposes an AR-spectrum into its compontents [w,A,B,R,P,F,ip] = ar_spa(AR,fs,E);

ARCEXT extracts AR and RC of order P from Matrix MX function [AR,RC] = arcext(MX,P);

ARFIT2 estimates multivariate autoregressive parameters of the MVAR process Y

BiAutoCovariance function [BiACF] = biacovf(Z,N);

BISDEMO (script) Shows BISPECTRUM of eeg8s.mat

Calculates Bispectrum [BISPEC] = bispec(Z,N);

DETREND removes the trend from data, NaN's are considered as missing values DETREND is fully compatible to previous Matlab and Octave DETREND with the following features added: - handles NaN's by

function [AR,RC,PE] = durlev(ACF); function [MX,PE] = durlev(ACF); estimates AR(p) model parameter by solving the Yule-Walker with the Durbin-Levinson recursion for multiple channels INPUT:

The use of FLAG_IMPLICIT_SAMPLERATE is in experimental state.

floating point index - interpolates data in case of non-integer indices

HISTO calculates histogram for each column [H,X] = HISTO(Y,Mode) Mode 'rows' : frequency of each row '1x' : single bin-values 'nx' : separate bin-values for each column X are th

HISTO2 calculates histogram for multiple columns with separate bin values for each data column.

HISTO3 calculates histogram for multiple columns with common bin values among all data columns, and can be useful for data compression.

HISTO4 calculates histogram of multidimensional data samples and supports data compression

HUP(C) tests if the polynomial C is a Hurwitz-Polynomial.

First Investigation of a signal (time series) - automated part [AutoCov,AutoCorr,ARPMX,E,ACFsd,NC]=invest0(Y,Pmax);

First Investigation of a signal (time series) - interactive [AutoCov,AutoCorr,ARPMX,E,CRITERIA,MOPS]=invest1(Y,Pmax,show);

invfdemo demonstrates Inverse Filtering

Estimates AR(p) model parameter with lattice algorithm (Burg 1968) for multiple channels.

Multivariate (Vector) adaptive AR estimation base on a multidimensional Kalman filer algorithm.

MVAR estimates parameters of the Multi-Variate AutoRegressive model

Multi-variate filter function

MVFREQZ multivariate frequency response [S,h,PDC,COH,DTF,DC,pCOH,dDTF,ffDTF,pCOH2,PDCF,coh,GGC,Af,GPDC,GGC2,DCOH] = mvfreqz(B,A,C,f,Fs) [...] = mvfreqz(B,A,C,N,Fs) INPUT: ======= A, B mult

Partial Autocorrelation function [parcor,sig,cil,ciu] = pacf(Z,N);

estimates partial autocorrelation coefficients Multiple channels can be used (one per row).

converts an AR polynomial into an autocorrelation sequence [R] = poly2ac(a [,efinal] );

Converts AR polymials into autoregressive parameters.

converts AR-polynomial into reflection coefficients [RC,R0] = poly2rc(A [,Efinal])

converts reflection coefficients to autocorrelation sequence [R] = rc2ac(RC,R0);

converts reflection coefficients into autoregressive parameters uses the Durbin-Levinson recursion for multiple channels function [AR,RC,PE,ACF] = rc2ar(RC); function [MX,PE] = rc2ar(RC);

converts reflection coefficients into an AR-polynomial [a,efinal] = rc2poly(K)

RMLE estimates AR Parameters using the Recursive Maximum Likelihood Estimator according to [1] Use: [a,VAR]=rmle(x,p) Input: x is a column vector of data p is the model order Output: a is

SBISPEC show BISPECTRUM

Model order selection of an autoregrssive model [FPE,AIC,BIC,SBC,MDL,CAT,PHI,optFPE,optAIC,optBIC,optSBC,optMDL,optCAT,optPHI]=selmo(E,N);

SELMO2 - model order selection for univariate and multivariate autoregressive models X = selmo(y,Pmax); y data series Pmax maximum model order X.A, X.B, X.C parameters of AR mode

SINVEST1 shows the parameters of a time series calculated by INVEST1 only called by INVEST1

TSADEMO demonstrates INVEST1 on EEG data

UCP(C) tests if the polynomial C is a Unit-Circle-Polynomial.

Y2RES evaluates basic statistics of a data series R = y2res(y) several statistics are estimated from each column of y OUTPUT: R.N number of samples, NaNs are not counted R.SUM sum

Reset the view box to automatic mode in the VIBes viewer.

Set axis labels for the current VIBes figure.

Connect to the VIBes viewer to send data for plotting.

Plot a single box with pairs of lower bounds and upper bounds.

Plot a line with coordinate points given as rows of a matrix.

Disconnect from the VIBes viewer.

Create a new figure named NAME.

Add a frame to an AVI file.

Create an AVI-format video file.

Return the properties of an AVI file.

Load frame N from the AVI file FILENAME.

[d,w,rx,cv,wx] = best_dir( x, [a , sx ] )

[cv,wx] = best_dir_cov(x,a,sx,wd) x D x P : a P x W : Same as in best_dir, but sx is compulsory.

y = bound_convex(d,h,x,pad=0)

s = data2vrml (typeStr, value) - Convert 'value' to VRML code of type typeStr

x = proplan(x,d,v=1)

save_vrml(outname,[options],s1,.

s = vmesh (x, y, z [, options] ) - Visualize a 3D surface s = vmesh (z [, options] )

s = vrml_Background (.

s = vrml_DirectionalLight (.

s = vrml_PointLight (.

vrml_ROUTE (eventout, eventin)

s = vrml_TimeSensor (.

s = vrml_anim (typ, val, eventin, time)

s = vrml_arrow (sz, col) - Arrow pointing in "y" direction

p = vrml_browse ([s]) - View vrml code s with FreeWRL vrml_browse ("-kill") - Kill the browser

s = vrml_cyl(x,.

v = vrml_ellipsoid (moment, col) - Ellipsoid

s = vrml_faces(x,f,.

s = vrml_flatten (x [, d, w, col]) - A planar surface containing x

v = vrml_frame (t, r, .

v = vrml_group (s1, s2 .

s = vrml_interp (typ, val,.

p = vrml_kill () - Kill the current vrml browser If a vrml browser has previously been launched with vrml_browse(), it will be sent a KILL signal.

s = vrml_lines(x,f,.

s = vrml_material (dc,ec,tr) - Returns a "material" vrml node

n = vrml_newname (root) - A name for a vrml node, starting by root vrml_newname ("-clear")

s = vrml_parallelogram (x,.

s = vrml_points(x,options) x : 3xP : 3D points

s = vrml_surf (x, y, z [, options] ) - code for a VRML surface s = vrml_surf (z [, options] )

s = vrml_text(t,.

s = vrml_thick_surf (x, y, z [, options] ) s = vrml_thick_surf (z [, options] )

v = vrml_transfo(s,t,r,c,d) s : string of vrml code.

Create a COM server using the PROGID identifier.

Close down all GNU Octave managed COM handles.

Release interfaces from COM object OBJ and then delete the COM server

Call get function on COM object OBJ.

Call invoke on OBJ to run a method, or obtain a list of all methods.

Release interfaces from COM object OBJ

Call set function on COM object OBJ to set property PROPNAME to value VALUE.

Grab positions of landmarks on the screen.

Determine whether H is a COM object.

Display a message box using the win32 API.

Read a value from the Windows registry.

internal function

Constant for dealer socket type.

Constant for recv flag DONTWAIT

Constant for getsockopt EVENTS value option

Constant for getsockopt and setsockopt IDENTITY value option

Constant for pair socket type.

Constant bitmask value for getsockopt EVENTS value option

Constant bitmask value for getsockopt EVENTS value option

Constant for publisher type.

Constant for pull socket type.

Constant for push socket type.

Constant for getsockopt RCVMORE value option

Constant for reply socket type.

Constant for request socket type.

Constant for router socket type.

Constant for send flag SNDMORE

Constant for subscriber type.

Constant for setsockopt subscribe option

Constant for getsockopt TYPE value option

Constant for setsockopt unsubscribe option

The zeromq package provides GNU Octave bindings to the ZeroMQ library to provide fast distributed messaging options using IPC, TCP, TIPC and multicasting.

Bind a zeromq socket to a endpoint.

Close a zeromq socket.

Connect a zeromq socket to a endpoint.

Disconnect a zeromq socket from an endpoint.

Get the value of errno from zeromq.

Get the current value of an option.

Wait up to timeout time for recieved data on socket.

Attempt to recieve up to LEN bytes of data from zeromq socket.

Attempt to send to DATA bytes of data to zeromq socket.

Set a socket option on a zeromq socket.

Create a zeromq socket.

Get the last error from zeromq.

Unbind a previously bound zeromq socket from a endpoint.

Get the ZeroMQ library version.