107 lines
4.3 KiB
C++
107 lines
4.3 KiB
C++
#ifndef MATLAB_FUNC
|
|
#define MATLAB_FUNC
|
|
|
|
#include "gamma_alg_global.h"
|
|
|
|
namespace Matlab {
|
|
|
|
PiecePoly mkpp(arma::rowvec breaks, arma::mat coefs, arma::rowvec d = arma::rowvec());
|
|
|
|
/* function v=ppval(pp,xx)
|
|
* PPVAL Evaluate piecewise polynomial.
|
|
* V = PPVAL(PP,XX) returns the value, at the entries of XX, of the
|
|
* piecewise polynomial f contained in PP, as constructed by PCHIP, SPLINE,
|
|
* INTERP1, or the spline utility MKPP. */
|
|
arma::mat ppval(arma::mat xx, PiecePoly pp);
|
|
|
|
/* peakSearch.m => calValues.m => calFcnEval.m => polyval.m
|
|
* function [y, delta] = polyval(p,x,S,mu) */
|
|
arma::mat polyval(arma::mat p, arma::mat x, arma::mat S = arma::mat(0, 1), arma::mat mu = arma::mat(0, 1));
|
|
|
|
/* polyval.m => filter.m ----Built-in function
|
|
* Y = FILTER(B,A,X) filters the data in vector X with the filter described
|
|
* by vectors A and B to create the filtered data Y. */
|
|
void filter(arma::mat& y, arma::mat B, arma::mat A, arma::mat X, arma::uword n);
|
|
|
|
/* POLYDER Differentiate polynomial.
|
|
* POLYDER(P) returns the derivative of the polynomial whose
|
|
* coefficients are the elements of vector P. */
|
|
void polyder(arma::mat &a, arma::mat &b, int nargout, arma::mat u, arma::mat v = arma::mat(0, 1) );
|
|
|
|
// function [p,S,mu] = polyfit(x,y,n)
|
|
arma::colvec polyfit(arma::colvec x, arma::colvec y , int n);
|
|
|
|
/* REALMIN Smallest positive floating point number.
|
|
* x = realmin is the smallest positive normalized double precision floating
|
|
* point number on this computer. Anything smaller underflows or is an IEEE
|
|
* "denormal".
|
|
*
|
|
* REALMIN('double') is the same as REALMIN with no arguments.
|
|
*
|
|
* REALMIN('single') is the smallest positive normalized single precision
|
|
* floating point number on this computer. */
|
|
double realmin(QString type = QString("double"));
|
|
|
|
int fix(double x);
|
|
arma::mat fix(arma::mat dataMat);
|
|
|
|
/*Y = ERF(X) is the error function for each element of X. X must be real.
|
|
* The error function is defined as:
|
|
* erf(x) = 2/sqrt(pi) * integral from 0 to x of exp(-t^2) dt. */
|
|
arma::mat m_erf(arma::mat x);
|
|
|
|
//function output = spline(x,y,xx)
|
|
arma::mat spline(arma::mat x, arma::mat y, arma::mat xx);
|
|
PiecePoly spline(arma::mat x, arma::mat y);
|
|
|
|
//function [x,y,sizey,endslopes] = chckxy(x,y)
|
|
void chckxy(arma::mat &x, arma::mat& y, arma::rowvec &sizey, arma::mat& endslopes, int nargout);
|
|
|
|
/* function pc = pwch(x,y,s,dx,divdif)
|
|
* PWCH Piecewise cubic Hermite interpolation
|
|
*
|
|
* PC = PWCH(X,Y,S) returns the ppform of the piecewise cubic Hermite
|
|
* interpolant f to the given data values Y and the given slopes S
|
|
* at the given data sites X. X must be a vector, and S must be of the same
|
|
* size as Y.
|
|
* If Y is a vector, then it must be of the same length as X and will be
|
|
* resized if necessary to be a row vector.
|
|
* If Y is a matrix, then size(Y,2) must equal length(X).
|
|
*
|
|
* With d equal to size(Y,1), the piecewise cubic Hermite interpolant f to
|
|
* these data is the d-valued piecewise cubic function with breaks at the
|
|
* data sites X that satisfies
|
|
*
|
|
* f(X(j)) = Y(:,j), Df(X(j)) = S(:,j), j=1:length(X) .
|
|
*
|
|
* PC = PWCH(X,Y,S,DX,DIVDIF) also asks for DX := diff(X) and DIVDIF :=
|
|
* diff(Y,1,2)./DX . */
|
|
PiecePoly pwch(arma::mat x, arma::mat y, arma::mat s, arma::mat dx = arma::mat(0,0), arma::mat divdif = arma::mat(0,0));
|
|
|
|
/* function [res1,res2] = spdiags(arg1,arg2,arg3,arg4)
|
|
* SPDIAGS Sparse matrix formed from diagonals.
|
|
* SPDIAGS, which generalizes the function "diag", deals with three
|
|
* matrices, in various combinations, as both input and output.
|
|
*
|
|
* [B,d] = SPDIAGS(A) extracts all nonzero diagonals from the m-by-n
|
|
* matrix A. B is a min(m,n)-by-p matrix whose columns are the p
|
|
* nonzero diagonals of A. d is a vector of length p whose integer
|
|
* components specify the diagonals in A.
|
|
*
|
|
* B = SPDIAGS(A,d) extracts the diagonals specified by d.
|
|
* A = SPDIAGS(B,d,A) replaces the diagonals of A specified by d with
|
|
* the columns of B. The output is sparse.
|
|
* A = SPDIAGS(B,d,m,n) creates an m-by-n sparse matrix from the
|
|
* columns of B and places them along the diagonals specified by d.
|
|
*
|
|
* Roughly, A, B and d are related by
|
|
* for k = 1:p
|
|
* B(:,k) = diag(A,d(k))
|
|
* end */
|
|
void spdiags(arma::mat &res1, arma::mat &res2, arma::mat arg1,
|
|
arma::mat arg2 = arma::mat(0,0), int arg3 = 0, int arg4 = 0);
|
|
|
|
}
|
|
|
|
#endif // MATLAB_FUNC
|