math.dll
Classes:
Functions:
- Decompose::Task_Func
- Decompose::Task_GetData
- Decompose::Task_ReceiveResult
- Decompose::Task_TaksError
- ErrorFunc
- ExpMEM::Func
- ExpMEM::Grad
- ExpMEM::Task_Func
- ExpMEM::Task_GetData
- ExpMEM::Task_ReceiveResult
- ExpMEMEx::Func
- ExpMEMEx::Grad
- ExpMEMEx::Task_Func
- ExpMEMEx::Task_GetData
- ExpMEMEx::Task_ReceiveResult
- Get3BytesBits(refer object MathImage, refer object SimpleLUT, refer object MathImage, refer object SimpleLUT, refer object MathImage, refer object SimpleLUT)
- Get6BytesBits(refer object MathImage, refer object SimpleLUT, refer object MathImage, refer object SimpleLUT, refer object MathImage, refer object SimpleLUT)
- InverseBits(int, int)
- MathImage::LoadImageSet
- PrintInFixedField
#module root.mathematic
Class Adams is intended for solving a Cauchy's system of equatations
by the method forecast and the correction of Adams of the 3rd order.
The system which is intended to be solved is the system of the form:
dy0/dx = F0(x, y0, y1, y2, ..., yn);
dy1/dx = F1(x, y0, y1, y2, ..., yn);
.........
dyn/dx = Fn(x, y0, y1, y2, ..., yn);
with the initial conditions ( x = x0)
y0(x0) = Y0;
y1(x0) = Y1;
......
yn(x0) = Yn;
Methods:
param System, StartConditions;
Fills base structures for solving the system of equations of Cauchy with Adams's method.
System - right sides of the equatations in the form: F(x, << y0, ..., yN >>).
StartConditions - the initial conditions, enumerated in the same order,
as the right sides of the equations.
For solving the equatations it is nessesary to call the SolveSystem method, belonging to the Cauchy class.
Class BSplineApprox is intended for
smoothing of functions with B- splines of the arbitrary order.
#module root.mathematic
Methods:
returns the value of a spline in point x.
param K, N, Func;
Creates an object for approximation of the function Func
with B-splines with the Kth order with the partition to N of intervals.
Quantity of points of partition must be more than K + 1.
The base functions B- spline B[.k][.i](.u) are different from zero in the following intervals:
x[i], x[i + k].
N[1][i](u) = (u <= x[i + 1] && u >= x[i]) ? 1.0 : 0.0;
for k > 1
N[k][i](u) = (u - x[i]) * N[k - 1][i](u) / (x[i + k - 1] - x[i]) + (x[i + k] - u) * N[k - 1][i + 1](u) / (x[i + k] - x[i + 1]);
param K, N, Func, MinProc;
Creates an object for approximation of the function Func
with B-splines with the Kth order with the partition to N of intervals.
Quantity of points of partition must be more than K + 1.
MinProc is the the procedure of the calculation of the minimized value
MinProc obtains 2 parameters (Weights and ExtrParam), where:
Weights is the vector is weight splines
ExtrParam is the vector of two elements
ExtrParam[0] is the pointer to an object BSplineApprox,
ExtrParam[1] is the to an array [ (N + K), Func- Len() ] of values of the base functions of spline
The base functions B- spline B[k][i](u) are different from zero in the following intervals:
x[i], x[i + k].
N[1][i](u) = (u <= x[i + 1] && u >= x[i]) ? 1.0 : 0.0;
for k > 1
N[k][i](u) = (u - x[i]) * N[k - 1][i](u) / (x[i + k - 1] - x[i]) + (x[i + k] - u) * N[k - 1][i + 1](u) / (x[i + k] - x[i + 1]);
Method returns the value of the derivative of spline at point x
Method recalculates the external coordinate (x) into the parametric (relative) coordinate t(.x)
param x, Coord_Derivative;
Method recalculates the external coordinate (x) into the parametric (relative) coordinate t(x) and the derivative dt/dx
Method returns the value of the second derivative of spline at point x
Class BSplineApproxEx is intended for the smoothing of functions with
B- splines of the arbitrary order with the uneven grid of control points.
The positions of control points are determined automatically.
#module root.mathematic
Methods:
param K, N, Func;
Creates an object for the approximation of functions Func by B- splines of order K with the partition to N intervals.
Quantity of points of partition must be more than K + 1.
The base functions B- spline B[.k][.i](.u) are different from zero in the following intervals:
x[i], x[i + k].
N[1][i](u) = (u <= x[i + 1] && u >= x[i]) ? 1.0 : 0.0;
for k > 1
N[k][i](u) = (u - x[i]) * N[k - 1][i](u) / (x[i + k - 1] - x[i]) + (x[i + k] - u) * N[k - 1][i + 1](u) / (x[i + k] - x[i + 1]);
param K, N, _Func, UniformNoice;
Creates an object for the approximation of functions Func by B-splines of order K with partition to N intervals.
Quantity of points of partition must be more than K + 1.
The base functions B- spline B[k][i](u) are different from zero in the following intervals:
x[i], x[i + k].
N[1][i](u) = (u <= x[i + 1] && u >= x[i]) ? 1.0 : 0.0;
for k > 1
N[k][i](u) = (u - x[i]) * N[k - 1][i](u) / (x[i + k - 1] - x[i]) + (x[i + k] - u) * N[k - 1][i + 1](u) / (x[i + k] - x[i + 1]);
Method recalculates the external coordinate (x) into the parametric (relative) coordinate t(x)
param x, Coord_Derivative;
Method recalculates the external coordinate (x) into the parametric (relative) coordinate t(x) and a derivative dt/dx
Class BSplineApprox is intended for smoothing of the functions with B-splines of arbitrary order.
#module root.mathematic
Methods:
- ()(number, number)
- BSplineApprox_2D(int, int, int, number, number, int, number, number, int, refer object Vector)
- BSplineApprox_2D(int, int, int, refer object TSurface)
- DerivativeX(number, number)
- DerivativeXZ(number, number)
- DerivativeZ(number, number)
- GetRelativeArgument(number, number)
- GetRelativeArgumentAndStretch(number, number, refer any)
- SecondDerivativeX(number, number)
- SecondDerivativeZ(number, number)
param x, z;
Returns the value of the spline in the point (x, z))
param K, N_X, N_Z, MinX, MaxX, MinZ, MaxZ, Data;
Creates an object for approximation of the surface.
Surface is determined by the collection of 3-dimensional points in the Data-array.
Each element of the Data-array contains vector with three coordinates - << x, z, y >>.
by two-dimensional B- splines of order K with partitioning to N_X x n_z intervals.
The quantity of points of partition for each direction must be more than K + 1.
param K, N_X, N_Z, Surf;
Creates an object for approximation of the surface Surf
with 2-dimensional B-splines of order K with partitioning to N_X x N_Z intervals.
The quantity of points of partition for each direction must be more than K + 1.
param x, z;
Method returns the value of the derivative of spline in direction X at point (x, z)
param x, z;
Method returns the value of the mixed second derivative of spline at point (x, z)
param x, z;
Method returns the value of the derivative of spline in direction X at point (x, z)
param x, z;
Method recalculates the external coordinates (x, y) into the parametric (relative) coordinates (u, v)
param x, z;
Method recalculates the external coordinates (x, y) into the parametric (relative) coordinates (u, v)
param x, z;
Method returns the value of the second derivative of the spline in direction X at point (x, z)
param x, z;
Method returns the value of the second derivative of the spline in direction X at point (x, z)
Class is intended for transfering the parameters
to the class of the decomposition of spectra.
#module root.mathematic
Methods:
Checks the correctness of the boundaries
Returns the linear list of the boundaries of the parameters.
Returns a linear list of fitting-parameters.
Sets the fitting interval.
Creates a description of spectrum on the basis of linearly enumerated fitting-parameters.
param sF, sW, sS, sP;
#rus Случайным образом меняет параметры с нормальным распределением
#rus вокруг текущего значения параметров.
#rus sF - дисперсия случайной частоты
#rus sW - дисперсия случайной ширины полосы
#rus sS - дисперсия случайной закоса
#rus sP - дисперсия степени светорассеяния
Randomly changes the parameters with the normal distribution
around the current value of the parameters.
sF - dispersion of the random frequency
sW - dispersion of random zone width
sS - (?)
sP - dispersion of the degree of the light diffusion
Randomly changes parameters
Class is intended for transfer of the parameters to the spectre decomposition class.
#module root.mathematic
Methods:
Returns the linear list of the boundaries of the parameters
Returns a linear list of fitting-parameters.
Creates a description of spectrum on the basis of linearly enumerated fitting-parameters.
#module root.mathematic
Base class for the decomposition of curve to the sum of the exponential curves
Methods:
#module root.mathematic
Base class for decomposition of curve to the sum of the extended exponential curves
Note: The extended exponential curve is determined by the expression:
Y[i] = Exp(- (X[i ]/Tau) ** Alpha)
Methods:
#module root.mathematic
locked spline curve
Methods:
Calculation of the spline value, using the following formule:
K
P(mu) = Sum A[i] * BetaBlend((K -2) * mu - i + 1.0)
i=0
where mu belongs to the interval [0,...,1]
K - number of control points
Determines the beta-spline which "tension" equals to 1.0
and "skew" equals to 0.0 which passes the points specified
via the P parameter.
P - is a vector of points of the POINT or POINT3 class
param P, skew, tension;
Gets base kinked curve points.
Returns a vector of pointers to the current object
fields which represent the POINT class objects.
param Point;
Method determines the position of point relative to outline.
It returns:
1 - if point lies inside the outline,
0 - if point lies on the outline
-1 - if point lies out of the outline
Gets base kinked curve points.
Returns a vector of pointers to the current object
fields which represent the POINT class objects.
Returns the vector of the discrete coordinates of Beta-spline points ( {X,Y})
param n;
Return the control point number n
Gets the basic points of a broken line.
Returns a vector of class POINT
param mu;
Find tangent of spline at parameter mu = [0,...,1]
param P;
Calculates control points of an interpolated Beta-spline
passing through points indicated in P.
P - vector of the points of class POINT or POINT3
param P;
Creates a spline.
P - vector of the points of class POINT or POINT3
param REBUILD_LEN; ( REBUILD_LEN >= 5 )
Rebuild the spline to obtain the linear parameter/length dependency
For this reason function find the point on the spline at the
position, where distannce from previous one is equial to
GetLength() / REBUILD_LEN ( REBUILD_LEN - new number of control points. )
param n, v;
Change the position of control point number n
#module root.mathematic
Class of a non-locked curve of a beta-spline
Methods:
param mu;
Calculation of the spline value using the following formula:
K
P(mu) = Sum A[i] * BetaBlend((K -2) * mu - i + 1.0)
i=0
where mu belongs to the section [0,...,1]
K - number of control points
param P;
Determines a beta-spline with tension equal to 1.0 ,
skew equal to 0.0 crossing the points specified in P.
P is a vector of points of class POINT or POINT3
param P, skew, tension;
Determines a beta-spline with given parameters,
crossing the points specified in P.
P is a vector of points of class POINT or POINT3
Finds the intersection of the spline with a straight line.
The straight line is determined by by a vector with inclination A and
a point B B -> P = A * tau + B
where tau is a parameter ofthe straight line.
From this form the equation of straight line is converted into the form
(y = alpha * x + beta, или x = alpha * y + beta),
depending on the value of A.
Newton's method is used for finding the point of intersection.
This method very fast, but is only stable ( converges)
if the initial value of parameter mu0 is sufficiently close
to the present point of intersection.
Method returns parameter mu, which correspond to the point intersection.
For obtaining the coordinates of point of intersection
method FindCrossection(A, B mu0) is called.
Obtains te basic points of a spline.
Returns a vector of pointers to the fields of the given object
being an object of the POINT or POINT3 class.
Returns a vector of discrete coordinates of the beta-spline points (in {X,Y} )
param n;
Returns the control point number n
Returns the total number of control points.
Returns a RECT covering the range of values of spline in space {X,Y}.
param mu;
Find tangent of spline at prameter mu = [0,...,1]
Returns a vector like
<< POINT( min{X}, min{Y} ), POINT( max{X}, max{Y} ) >>
covering the range of values of spline in space {X,Y}.
Returns a vector like
<< POINT( min{X}, min{Y}, min{Z} ), POINT( max{X}, max{Y}, max{Z} ) >>
covering the range of values of spline in space {X,Y}.
param P, skew, tension;
Determines a beta-spline with given parameters
crossing points specified in P.
P - vector of points belonging to POINT or POINT3 class.
param P;
Calculates the control points of the interpolated beta-spline
crossing points specified in P.
P - vector of points belonging to POINT or POINT3 class.
param REBUILD_LEN; ( REBUILD_LEN >= 5 )
Rebuild a spline in order of getting a linear correlation
of the length of the curve with the parameter.
Searching for a point on a spline , where the distance to previous point equals
GetLength() / REBUILD_LEN.
(REBUILD_LEN - new number of control points)
param n, v;
Change the position of control point number n.
param s, t;
set skew and tension of a spline.
Class BetaSpline contains parameters determining the spline
- the collection of datum (?) (control) points
- "tension" and "skew". This class is base for all classes of Beta-splines.
Spline is parametric function with the parameter being changed from 0 to 1.
The pairs of coordinates (x, y) are composed from the values of a spline.
#module root.mathematic
Methods:
Blend Function of qubic beta-splines
Derivation of Blend Function of qubic beta-splines
#module root.mathematic
Class is intended for fully automatic decomposition of a spectrum
to a number of Gauss components by gradient descent.
Methods:
- BlindExpDecompose(refer object TFunc, number, int, int, number, any, boolean, boolean, boolean, boolean)
- BlindExpDecompose(refer object TFunc, number, int, int, number, number, boolean, boolean, boolean, boolean)
- MakeDecomposition(void)
param Curve, StartPoint, NumbItterations, NumbResults, Accuracy, IsPositive, CheckOffset, NoDispersion;
Creates an object for unguided analysis of decomposition to exponents
param Curve, StartPoint, NumbItterations, NumbResults, Accuracy, MaxAmplitude, IsPositive, CheckOffset, NoDispersion;
Constructs an object for unguided analysis of decomposition to exponents
Method decomposes to Gauss components and returns an array of BlindExpDecompose
objects, sorted in descending order of probability
#module root.mathematic
Class is intended for fully automatic decomposition of a spectrum
to a number of Gauss components by gradient descent.
Methods:
param Curve, NumbItterations, NumbResults, Accuracy, IsWaveLength, IsPositive, CheckOffset, NoDispersion;
Creates an object for unguided analysis of decomposition to Gauss exponents
Method decomposes to Gauss components and returns an array of BlindExpDecompose
objects, sorted in descending order of probability
#module root.mathematic
Class is intended for fully automatic decomposition of a spectrum
to a number of Gauss components by gradient descent.
Methods:
- BlindGlobExpDecompose(refer object Vector, number, int, int, number, boolean, boolean, boolean, boolean)
- BlindGlobExpDecompose(refer object Vector, number, int, int, number, number, boolean, boolean, boolean, boolean)
- MakeDecomposition(void)
param Curve, StartPoint, NumbItterations, NumbResults, Accuracy, IsPositive, CheckOffset, NoDispersion;
Creates an object for unguided analysis of decomposition into exponents
param Curve, StartPoint, NumbItterations, NumbResults, Accuracy, MaxAmplitude, IsPositive, CheckOffset, NoDispersion;
Creates an object for unguided analysis of decomposition into exponents
Method decomposes to Gauss components and returns an array of BlindExpDecompose
objects, sorted in descending order of probability
#module root.mathematic
Class is intended for fully automatic decomposition of a spectrum
to a number of Gauss components by gradient descent.
Methods:
param Curves, NumbItterations, NumbResults, Accuracy, IsWaveLength, IsPositive, CheckOffset, NoDispersion;
Creates an object for unguided analysis of decomposition into Gauss components
Method decomposes to Gauss components and returns an array of BlindExpDecompose
objects, sorted in descending order of probability
#module root.mathematic
Solution of an ordinary linear differential equation
of the second order with the assigned boundary conditions by the dispersion method.
Methods:
- BoundDiff2(refer object Function, refer object Function, refer object Function, refer object Function, number, number, number, number, number, number, number, number, int)
- BoundDiff2(refer object Function, refer object Function, refer object Function, refer object Function, refer object Vector, number, number, number, number, number, number)
- Solution(void)
param G, H, U, F, a0, b0, c0, aN, bN, cN, From, To, N;
Solution of an linear differential equation of the second order
like:
G(x) * d2y/dx2 + H(x) * dy/dx + U(x) * y + F(x) = 0
in the interval [ From, To ] on the uniform grid
with N knots with the assigned boundary conditions in the following form:
a0 * dy/dx (From) + b0 * y(From) + c0 = 0
aN * dy/dx (To) + bN * y(To) + cN = 0
param G, H, U, F, X_Array, a0, b0, c0, aN, bN, cN;
Solution of an linear differential equation of the second order
like:
G(x) * d2y/dx2 + H(x) * dy/dx + U(x) * y + F(x) = 0
in the interval specified by the set of points X_Array
with specified boundary conditions in the following form:
a0 * dy/dx (x0) + b0 * y(x0) + c0 = 0
aN * dy/dx (xN) + bN * y(xN) + cN = 0
x0 - first point of the interval
xN - last point of the interval
returns solution
#module root.mathematic
Class Cauchy is a base class for methods solving
a Cauchy's system of equatations.
The equatation system is a system like:
dy0/dx = F0(x, y0, y1, y2, ..., yn);
dy1/dx = F1(x, y0, y1, y2, ..., yn);
.........
dyn/dx = Fn(x, y0, y1, y2, ..., yn);
with initial conditions (x = x0)
y0(x0) = Y0;
y1(x0) = Y1;
......
yn(x0) = Yn;
Methods:
param Flg;
Allows/forbids using the progress bar,
while solving the equatation system.
param System, StartConditions;
Fills the base structures for solving a Cauchy's equatation system.
System - the right sides of the system of equations in following form:
F(x, << y0, ..., yN >>)
StartConditions - the initial conditions, enumerated in the same order,
like the right sides of the equations
Returns the actual number of steps required for solving the equatation system.
param FuncNames;
Determines the names of the unknown variables of the system.
param From, To, N;
It solves system in the interval [ From, To ] equally divided to N points.
param X_Array;
Solves the system on the intervall specified by the array X_Array
param n;
Returns n-th solution.
param FuncName;
Returns solution with the name FuncName.
#module root.mathematic
Class is intended for finding a minimum of multidimensional function
using the coordinate-by-coordinate descent method.
Methods:
param Func, Boundaries, StartPoint, Accuracy;
Creates an object Climb for finding a minimum of a multidimensional function Func
using the coordinate-by-coordinate descent method.
Parameters:
Func: Function receiving 2 parameters:
- an array of variables in space of which the method searches for the solution.
- an auxiliary parameter determined by the user
by calling the SetExtraParam method.
Function must return a value which has to be minimized.
Boundaries - an array of boundary value pairs
(the starting point of solution search)
Accuracy - accuracy of the seach for the solution
search for the solution is finished, when when the distance
between the subsequent points of approximation of solution
will be is less than Accuracy)
param A, NoDispersion, NumberPoints, M;
Returns non-normalized probability of a model.
A - regression parameters
if NoDispersion == TRUE the noise dispersion is not considered
during the discrepancy calculation.
NumberPoints - the number of points while calculating hi-2
M - number of independent components of the model.
Returns the solution of the equatation system.
param Derivative2;
Determines the function of calculating
the mixed second derivative of the function which has to be minimized.
Derivative2 - function receiving 4 parameters:
- an array of variables, in the space of which the solution is searched for.
- the number of the 1st parameter on which is differentiated.
- the number of the 2nd parameter on which is differentiated.
- random help parameter which is assigned by the user
by calling the SetExtraParam method.
param Derivative;
Determines the function of calculating
the derivative of the function which has to be minimized.
Derivative - function receiving 3 parameters:
- an array of variables, in the space of which the solution is searched for.
- the number of the parameter on which is differentiated.
- random help parameter which is assigned by the user
by calling the SetExtraParam method.
param ErrorIfMaxItterNumberExceed;
If ErrorIfMaxItterNumberExceed == TRUE:
if the number of iterations has reached MaxIterationNumber
but the expected accuracy is not achieved an error will occur.
SetErrorIfMaxItterNumberExceed == FALSE, the error will not occur.
ErrorIfMaxItterNumberExceed == TRUE is default value.
param Gradient;
Determines the function for calculation of the gradient of the function,
which has to be minimized.
Gradient is a functiopn, which receives 2 parameters:
- an array of variables, in the space of which the solution is searched for.
- random help parameter which is assigned by the user
by calling the SetExtraParam method.
Function must return MVector.
param MaxRealtiveStepNorm;
Sets the maximal relative step of the change of the norm
of the fitting parameter vector.
Sets the maximal step.
Sets the minimal step.
param SelectedDirections;
Sets the function to calculate the selected directions of the search for the minimum.
SelectedDirections - function, receives 2 parameters:
- an array of variables, in the space of which the solution is searched for.
- random help parameter which is assigned by the user
by calling the SetExtraParam method.
Function must retur Vector, each elemet of which must contain a vector
indicating the chosen direction of the search.
Sets the starting point.
param NumbDFPItterations;
Searches for the minimum using the combined method of Powell / David-Fletcher-powell.
The maximum number of iterations is determined using the David-Fletcher-Powell method.
Searches for the minimum using the combined method of Powell / David-Fletcher-Powell.
Searches for the minimum using the
Broyden-Fletcher-Golfarb-Shanno's method.
Searches for the minimum using the coordinate-by-coordinate descent method.
Parameters: 1. Vector of initial steps.
Searches for a minimum of a function which is a sum of several functions.
The functions of the gradients must be specified using the method
Climb::SetDoubleGradFunc.
Searches for a minimum using the Davidon-Fletcher-Powell method.
Searches for a minmum using the dynamic method.
It makes sense using this method if there is an exact expression for calculating
the gradient of the function which has to be minimized.
This expression must be determined using the SetGradFunc method.
param RepeatFreshStep;
Searches for the minimum using the Powell method.
If RepeatFreshStep == FALSE, the repeated approach from the initial array
wont take place.
Searches for the minimum in subspace of limited dimensionality
using the Powell method.
Searches for the minimum using the Powell method.
#module root.mathematic
Class dor finding a minimum of a multidimensional function using the
coordinate-by-coordinate descent method.
Methods:
- ClimbDouble(refer any, refer object Vector, refer object Vector, number)
- GetResult(void)
- SetDeriv2Func(refer any)
- SetDerivFunc(refer any)
- SetErrorIfMaxItterNumberExceed(boolean)
- SetExtraParam(refer any)
- SetGradFunc(refer any)
- SetMaxItterationNumber(int)
- SetMaxRealtiveStepNorm(number)
- SetMaxStep(refer object Vector)
- SetMinStep(refer object Vector)
- SetProgressWnd(refer object GProgressWnd)
- SetSelectedDirectionsFunc(refer any)
- SetSilent(boolean)
- SetStartPoint(refer object Vector)
- Solve(int)
- Solve(void)
- SolveBFGS(void)
- SolveByCoord(refer object Vector)
- SolveBySelectedDirections(void)
- SolveDFP(void)
- SolveDynamic(void)
- SolvePowell(boolean)
- SolvePowell(refer object Vector)
- SolvePowell(void)
- ~ClimbDouble(void)
#module root.mathematic
Class Complex introduces complex numbers and supports
the arithmetic manipulations with them.
Methods:
- *(number)
- *(refer object Complex)
- **(number)
- *=(number)
- *=(refer object Complex)
- +(number)
- +(refer object Complex)
- +=(number)
- +=(refer object Complex)
- -(number)
- -(refer object Complex)
- -(void)
- -=(number)
- -=(refer object Complex)
- /(number)
- /(refer object Complex)
- /=(number)
- /=(refer object Complex)
- Complex(copy)
- Complex(number)
- Complex(number, number)
- Complex(refer object Complex)
- Complex(void)
- Conjugate(void)
- Module(void)
- Print(void)
Class ComplexVesicule
#module root.mathematic
Class for describing vesicules on microscopic images,
shown as a superposition of rounded spots.
(Vesicule class objects)
Methods:
- *=(number)
- AddSubVesicule(refer object Vesicule)
- AddSubVesicules(refer object Vector)
- ComplexVesicule(refer object Vector)
- Convolve(refer object Vesicule)
- GetMatrix(number, number, number, number, int)
- GetRange(void)
- GetSquare(void)
- GetVolume(void)
- Init(void)
- Shift(number, number)
- SplitVesicule(number, number, number, number)
- TransformCoordinate(number, number, number)
Returns the roll of the vesiculae
Returns the area of vesicule on half-height
Returns the volume of vesicule on half-height
param dx, dy;
Shifts Vesicule on (dx, dy).
param X0, Y0, X1, Y1;
Attempts to split Vesicule with isolation of the part
which fits the best the specified parameters.
#module root.mathematic
Class curve extends the TFunc class with the Comment field
and eventually extra information in the Info field.
The Disp field may contain dispersion.
Methods:
- *(number)
- *(refer object Curve)
- **(number)
- *=(number)
- *=(refer object Curve)
- +(refer object Curve)
- +=(refer object Curve)
- -(refer object Curve)
- -=(refer object Curve)
- /(number)
- /(refer object Curve)
- /=(number)
- /=(refer object Curve)
- Comment(void)
- Curve(copy)
- Curve(number, number, number, any)
- Curve(number, number, number, any, object String)
- Curve(refer object Curve)
- Curve(refer object Histogram, boolean)
- Curve(refer object TFunc)
- Curve(refer object Vector, refer object Function)
- Curve(refer object Vector, refer object Function, object String)
- Curve(refer object Vector, refer object Vector)
- Curve(refer object Vector, refer object Vector, object String)
- Curve(void)
- GetDispersion(boolean)
- GetInfo(void)
- HasDispersion(void)
- Mid(int, int)
- Modifyed(void)
- Remove(int, int)
- ScaleDispersion(number)
- SetDispersion(refer object TFunc)
- SetInfo(any)
param dy;
Returns a tabular function, derived from the tabular function
which becomes the message, by multiplying all y values with dy.
param f;
Returns a tabular function, which is the function becoming the message
multiplied with tabular function f.
param p;
Returns a tabular function, derived from the tabular function
which becomes the message, by erection of all values y into the degree r.
param f;
Multiplies the function which received the message with f.
Returns a reference to self.
param f;
Returns a tabular function which is sum of the function
which received the message and the tabular function f.
param f;
Adds the function which received the message to the function f.
Returns a reference to self.
param f;
Returns a tabular function being the difference between
the function, which received the message, and the tabular function f.
param f;
#rus Производит вычитание из функции, получившей сообщение,
#rus функции f. Возвращает ссылку на self.
Subtracts the function which received the message from the function f.
Returns a reference to self.
param dy;
Returns a tabular function, derived from the tabular function
which becomes the message, by dividing all y values through dy.
param f;
Returns a tabular function, which is the function becoming the message
divided through tabular function f.
param f;
#rus Производит деление функции, получившей сообщение на
#rus функцию f. Возвращает ссылку на self.
Divides the function which received the message through the function f.
Returns a reference to self.
Copyconstructor
param from, to, nstep, Func;
A tabular function is created in which X changes from "from" to "to",
with a quantity of steps equal to "nstep". The values of Y are determined by
the values of of the "Func" function in the appropriate points.
param from, to, nstep, Func, Comment;
A tabular function is created in which X changes from "from" to "to",
with a quantity of steps equal to "nstep". The values of Y are determined by
the values of of the "Func" function in the appropriate points
with a comment "Comment".
Copyconstructor
Constructor for creating a function from a histogramm with conversion.
Constructor for creating of a Curve object from a TFunc object.
param X, F;
A tabular function based on X array and the F function is created.
param X, F, Comment;
A tabular function based on X array and the F function is created,
with a "Comment" comment.
param X, Y;
A tabular function based on X and Y vectors is created.
param X, Y, Comment;
A tabular function based on X and Y vectors with a comment "Comment" is created.
Empty constructor.
param Recalculate;
Returns the estimation of dispersion for the noised experimental function.
If Recalculate == TRUE and the estimation was saved a recalculation is performmed.
Returns additional information.
param Offset, Len;
#rus Возвращает кривую, полученную вырезанием из данной
#rus кривой куска длиной Len от точки Offset.
Returns a curve, obtained by cutting a piece with lenght Len,
beginning with the point Offset, from target curve.
Method is called if a significant function modification occur,
leading to the need for reconstructing the auxiliary fields in the heirs.
param offset, len;
Removes len points from the curve beginning with the offset position.
param scale;
Scales the estimation of the dispersion
param info;
Sets additional information
#module root.mathematic
Base class for fitting curve by sum of curves
Methods:
param Result;
#rus Метод добавляет фиксированный результат к накопленному множеству
#rus ДОЛЖЕН БЫТЬ ОПРЕДЕЛЕН В КЛАССЕ-НАСЛЕДНИКЕ
param Result;
Method adds sequential result to the accumulated set.
It must be determined in the class-heir!
param Result;
Arranges results if it makes sense.
It must be determined in the class-heir!
#rus Метод вычисляет вариации и амплитуды полученных результатов
#rus ДОЛЖЕН БЫТЬ ОПРЕДЕЛЕН В КЛАССЕ-НАСЛЕДНИКЕ
#rus Метод вычисляет вариации амплитуд полученных результатов
#rus ДОЛЖЕН БЫТЬ ОПРЕДЕЛЕН В КЛАССЕ-НАСЛЕДНИКЕ
Method calculates the amplitudes of the obtained results.
It must be determined in the class-heir!
param Result;
Method returns a component array, corresponding with the solution result.
Must be declared in the class-heir!
param Result, X;
Method returns a component array, corresponding with the solution result.
Must be declared in the class-heir!s
Method returns minimal amplitudes of the fitting-steps.
If it is nessesary to set minimal fitting-steps ,
method must be declared in the class-heir!
Returns the number of points with which the fitting was made.
param Result;
Returns non-normalized probability of a result.
param Result;
Method returns TRUE if after finding the minimum, it is nessesary
to repeat the descent with a modified function.
Solution seacrh
Parental window for the windows of progress is established.
The rule of positivity (not for the nondifferential spectra) is established
param Result;
Method, which calculates function for optimizing,
normalized to the dispersion.
Must be declared in the class-heir!
param Result, Amplitudes;
Method, which calculates function for optimizing,
normalized to the dispersion.
It is differed from SquareDiff(refer object Vector),
in terms of the fact that besides the parameters which are determined,
linear amplitudes during the decomposition are assigned.
Must be declared in the class-heir!
#module root.mathematic
Base class for fitting one curve by sum of curves
Methods:
#rus Метод вычисляет вариации и амплитуды полученных результатов
param Curves, UseDispersionFromCurve, FitParams;
param Index, j, X;
Returns the approximating curve of solution Index for to the curve j specific at points X.
param Index, j, X;
Returns the curve of component j in solution Index specified in Points X.
Returns the number olf points on which fitting was made.
param Index, j, X;
Returns the offset curve in solution Index for the curve j specified at points X.
param Result;
Calculates the function which is to be optimized, normalized for dispertion.
param Result;
Calculates the function which is to be optimized, normalized for dispertion.
#module root.mathematic
Class for storing the resultates of decomposition (regression).
Methods:
param Result, ResVariation, Residue, Probability, Boundaries;
#module root.mathematic
Base class for fitting one curve by sum of curves
Methods:
#rus Метод вычисляет вариации и амплитуды полученных результатов
param Curves, UseDispersionFromCurve, FitParams;
Calculates amplitudes of received resultates
param Index, X;
Returns an approximated kurve of the solution Index specified in points X.
param Index, j, X;
Returns a curve of the j component in solution Index cpecified in points X.
Returns the number of points which the fitting was made.
param Index, X;
Returns the offset curve in solution Index specified inpoints X.
param index;
Text printout of the result o fthe solution index.
Must be specified in class-heir!
param Result;
Method calculating the function to be optimized, normalized for dispersion.
param Result;
Method calculating the function to be optimized, normalized for dispersion.
#module root.mathematic
Class DotHelix implements the Dot-Helix algorithm for finding
pattern (statistically significant sequential positive deviations
from the average value) in the sequence of quasi-random numbers.
Methods:
param n;
Returns the n-th pattern
param WFunc, Average, SD, Threshold;
Searches for pattern on a sequence of quasi-random numbers WFunc.
Average - true average value ( for random sequence without the characteristics)
SD - square root from dispersion ( for random sequence without the characteristics)
Threshold - threshold of the isolation of special feature measured in the units of dispersion.
Finds all patterns above the threshold.
Finds all patterns above the threshold. ( maybe not all))
Returns the number of found patterns
Sets the shift of the average value.
Class for calculating the error integral.
#module root.mathematic
Class for passing the parameters to the global fitting method.
Methods:
#module root.mathematic
Class is intended for passing the parameters to the histogramm decomposition class.
Methods:
Creates a description based on sequentially enumerated fitting parameters.
#module root.mathematic
Class for passing the information about one and the same distribution
Methods:
Checks the correspondance of the boundaries
param LogTau, Amp;
param LogTau, Amp, Boundaries;
Returns the sequential list of boundaries of the fitting-parameters
Returns the sequential list of fitting parameters
#rus Случайным образом меняет параметры
Randomly changes parameters.
#module root.mathematic
Fit curve by sum of exponents by Newton algorithm
Methods:
- ExpFitting(refer object Function, int, number, boolean)
- ExpFunc(int, refer object Vector, refer object Vector)
- ExpFunc1(int, refer object Vector)
- FindAmplitudes(refer object Vector)
- Fit(int)
- Fit(object Vector)
- Fit(object Vector, object Vector)
- GetFunc(refer object Vector, int)
- GetNumbVersions(void)
- GetResidue(refer object TFunc, int)
- GetTau(int)
- Jacobian(int, int, refer object Vector, refer object Vector)
- ReSelectStartPoint(object Vector, object Vector)
- ReSelectStartPoint(object Vector, object Vector, object Vector)
- SetAlpha(object Vector)
- SetProgress(refer object GProgressWnd)
- SetSilent(boolean)
- TryFitUpTo(int)
Methods:
param Curve, ExpList;
param Res;
Method returns a component array, corresponding with the result Result.
param index;
Text printout of the result index
#module root.mathematic
Class for finding the spectrum of the exponents with the maximum entropy method.
Methods:
- ConcateOmegaPos(void)
- ExpMEM(object TFunc, number, number, number, boolean, boolean, boolean, boolean, int, int, int, boolean)
- FindOmegaPos(void)
- GetApproximation(void)
- GetCPPClassSize(void)
- GetDistribution(void)
- GetEntropy(refer object Vector, boolean)
- GetFitResidue(void)
- GetGradient(refer object Vector, number, boolean, boolean)
- GetLogZs(number, boolean)
- GetMEMResidue(void)
- GetMonteCarlo(void)
- GetRawDistribution(void)
- Init(int)
- MonteCarlo(int, int, refer ...)
- Print(void)
- Reset(void)
- SerializeCPPClass(void)
- SetApproximateAlpha(boolean)
- SetAutomaticFindOmegaPos(boolean)
- SetFitOmega(boolean)
- SetFitOmegaPos(boolean)
- SetFixedOmega(number)
- SetOmega(refer object Vector)
- SetOmega(refer object Vector, refer object Vector)
- SetOmegaPos(object Vector)
- SetPrior(refer object Vector)
- SetSearchStartAmp(boolean)
- SetStartNumberPointsOnDecade(int)
- SimulateCurve(void)
- SmoothSpectrum(refer object Vector)
- SmoothSpectrum(refer object Vector, object Vector)
- Solve(int, refer ...)
- UnSerializeCPPClass(refer object String)
- _GetPrior(refer object Vector, boolean, boolean)
Concatenation of similiar intervals.
param Func, From, To, Start, Sharp, SkipZero, BaseLine, IsPositive, NumbIterattions, NumbOmega, UseAppServer;
Func - function which is analyzed
(From, To) - function interval in which the speed spectrum is analyzed.
Start - the moment when process begins.
If Sharp == TRUE, the spectrum is sharpened
If SkipZero == TRUE, then while analyzing the values
with an amplitude below the threshold are excluded.
If BaseLine == TRUE, the method searches for the zero function.
If IsPositive == TRUE, the method searches for results with positive amplitudes.
If UseAppServer == TRUE, thenan application server is used while calculating.
Method splits Omega to intervals.
Method returns an approximation curve,
obtained along the calculated spectrum.
Method returns the speed distribution found by the Solve method.
Method returns the residue of the approximating curve.
Method returns the residue of the maximu entropy method.
Method returns a reference to an array of spectres obtained by Monte-Carlo simulation.
Method returns the raw distribution found by the Solve method.
param N_max, MonteCarloCount, [Progress];
Method simulates kinetics based on spectrum MonteCarloCount which is found with
Monte-Carlo method. For the simulated kinetics the spectrums
specified in N_max points are found.
If an optional parameter Progress ( window of the GProgressWnd class) is specified
the progress of calculation is shown.
Returns an output line with the fitting results.
param ApproximateAlpha;
If ApproximateAlpha == TRUE, then after first approximation the calculation of
the probability integral for the marginalization of Alpha, is replaced by an
approximated expression Exp(-Alpha_p * Entropy),
where Alpha_p is taken by the equal to the relation of the logarithm of the integral
to the entropy value.
param AutomaticFindOmegaPos;
If AutomaticFindOmegaPos == TRUE, then an automatic detection
of the positions of the partition of Omega is performed.
param FitOmega;
If FitOmega == TRUE, Omega is determined.
param FitOmegaPos;
If FitOmegaPos == TRUE, the positions of the partition of omega are refioned.
Sets fixed Omega value. Subseqently Omega is not searched for anymore.
Partitioning to areas is blocked.
param OmegaPos;
Sets predetermined partition partition of smoothing.
param FitOmega;
If SearchStartAmp == TRUE, the starting amplitude is determined.
Method sets the number of start points on decade.
Method simulates the kinetics based on found spectrum
using the initial curve dispersion method.
Returns the simulated kinetics.
param N_max, [Progress];
Method finds the spectrum determined in N_max points.
If the parameter Progress is specified ( GProgressWnd class window),
a progress output is generated.
#module root.mathematic
Class for finding the exponent spectrum using the maximum entropy method.
Methods:
- ExpMEMEx(object TFunc, number, number, number, boolean, boolean, boolean, boolean, int, boolean, int, boolean)
- GetApproximation(void)
- GetCPPClassSize(void)
- GetDistribution(void)
- GetEntropy(refer object Vector, boolean)
- GetFitResidue(void)
- GetFuncPtr(void)
- GetGradPtr(void)
- GetGradient(refer object Vector, number, boolean, boolean)
- GetLogIntegralIDerivative(number)
- GetMEMResidue(void)
- GetRawDistribution(void)
- GetResidue(refer object Vector, number, boolean, boolean)
- Init(int, int, int)
- Init(refer object Vector, refer object Vector, refer object Vector)
- InitAppServer(void)
- InitKinetics(void)
- LogIntegralI(number)
- Print(void)
- Reset(void)
- SerializeCPPClass(void)
- SetApproximateAlpha(boolean)
- SetFitOmega(boolean)
- SetFixedOmega(object Vector, object Vector)
- SetOmega(refer object Vector, refer object Vector)
- SetOmegaBoundaries(object Vector)
- SetPrior(refer object Vector)
- SetStartNumberPointsOnDecade(int)
- SetTau(refer object Vector, refer object Vector)
- SimulateCurve(void)
- SmoothSpectrum(refer object Vector)
- SmoothSpectrum(refer object Vector, object Vector)
- Solve(int, refer ...)
- UnSerializeCPPClass(refer object String)
- ~ExpMEMEx(void)
param Func, From, To, Start, Sharp, SkipZero, BaseLine, IsPositive, NumbItterations, DoubleSpectra, NumbOmegaSearchLevels;
Func - the function which must be analyzed.
(From, To) - function interval, in which the speed spectrum is analyzed.
Start - process start moment
If Sharp == TRUE, the spectrum is sharpened.
If SkipZero == TRUE, the values with an amplitude below
the threshold are excluded while analyzing.
If BaseLine == TRUE, the method searches for the zero line.
If IsPositive == TRUE, the method searches a Result with a positive amplitude.
Method returns an approximation curve obtained using the calculated spectrum.
Method returns speed distribution found by the solve method.
Returns the residue of the approximating curve.
Returns the residue of the maximum entropy method.
Method returns raw distribution found by the Solve method.
#privare
Method returns an approximating curve obtained using the calculated spectrum.
Prints result of fitting.
param ApproximateAlpha;
If ApproximateAlpha == TRUE, after firs approximation step, the calculation of
the probability integral for marginalisation of Alpha is replaced by
an approximated expression Exp(-Alpha_p * Entropy), where Alpha_p
is taken by the equal to the ratio of the logarithm of the integral, to the
value of entropy.
param FitOmega;
If FitOmega == TRUE, Omega is determined.
Устанавливает фиксированное пользователем значение Омега и его интервалы. В дальнейшем
поиск Омега не производится.
Sets a fixed value of omega and the intervals.
Subsequently no search for Omega is performed.
Sets fixed partition of the values of Omega on the intervals.
#rus Метод устанавливает количество начальных разбиений на декаду по тау.
Method sets the number of start points on decade.
Simulates kinetics based on found spectrum
using the initial curve dispersion method.
Returns the simulated Kinetics.
param N_max, [Progress];
Method finds the spectrum specified in N_max points.
If the Progress parameter is specified (GProgressWnd class window)
a calculation progress output is generated.
Methods:
param Curve, ExpList;
param Res;
Returns an array of components, corresponding with the result Res.
param index;
#rus Текстовая распечатка результа решения index
Prints the result of index.
#module root.mathematic
Class ExpTauItem describes the elements of the array ExpTauItemList
Methods:
Checks whether boundaries fit.
#module root.mathematic
Class is intended for passing parameters to the BaseExp class.
Methods:
Randomly changes parameters.
#module root.mathematic
Performs fast discrete fourier transformation.
Methods:
- Amplitude(void)
- FFT(refer object Function, number, number, int, boolean)
- FFT(refer object Function, refer object Function, number, number, int, boolean)
- FFT(refer object Function, refer object Function, number, number, int, boolean, boolean)
- Im(void)
- Init(refer object TFunc, refer object TFunc, number, number, int, boolean)
- Phase(void)
- Re(void)
- Spectr(void)
Returns a TFunc function being the amplitude part of fourier matrix (?)
of the initial function.
param Func, From, To, N, Direction;
Fast fourier transformation of the Func function in the section [ From, To ].
Section is divided to N points.
If Direction == TRUE, then straight transformation is used,
otherwise reverse transformation is used.
param ReFunc, ImFunc, From, To, N, Direction;
Fast fourier transformation of a function pair ReFunc and ImFunc in
the section [ From, To ]. It is assumed , that ReFunc contains a real component
of the function which has to be transformed, and ImFunc - an imaginary component.
The section is splitted in N points. If Direction == TRUE,
then straight transformation is used,
otherwise reverse transformation is used.
param Func1, Func2, From, To, N, Direction, FuncType;
Fast fourier transformation of a function pair ReFunc and ImFunc in
the section [ From, To ]. The section is divided in N points.
If Direction == TRUE,then straight transformation is used,
otherwise reverse transformation is used.
If FuncType == TRUE, then Func1 contains a real component
of the function which has to be transformed, and Func2 - the imaginary component.
Else Func1 contains the amplitude and Func2 the Phase.
Returns a TFunc function, being an imaginary part of the
of fourier matrix (?) of the initial function.
param Re, Im, From, To, N, Direction;
Fast fourier transformation of the Func function (real) on section [From, To].
The section is divided in N Points.
If Direction == TRUE,then straight transformation is used,
otherwise reverse transformation is used.
Returns a TFunc function, being a phase of the
fourier matrix (?) of the initial function.
Returns a TFunc function, being a real part of the
fourier matrix (?) of the initial function.
#rus Возвращает комплексную функцию (TFunc), являющуюся
#rus фурье-образом исходной функции.
Returns a complex TFunc function, being a
fourier matrix (?) of the initial function.
#module root.mathematic
Basic class for passing the parameters in curve decomposition classes.
The List field contains a vector of objects
describing the decomposition parameters.
Methods:
- CheckBoundaries(void)
- FitParams(object Vector, boolean, boolean, int, int, number, number, number)
- FitParams(void)
- From(void)
- GetBoundaries(void)
- GetNumbComponents(void)
- GetNumbItterations(void)
- GetNumbResults(void)
- GetParams(void)
- SetParams(refer object Vector, refer object Vector, int)
- ShakeData(number, ...)
- ShakeData(void)
- To(void)
Checks whether boundaries fit.
Begin of the decomposition intervals.
Returns the boundaries of the decomposition parameters.
Returns the number of components.
Returns the number of iterations.
Returns the number of results.
Returns the decomposition parameters.
Creates a description of components based on
sequentially enumerated fitting parameters.
Must be declared in the class-heir!
Randomly changes parameters.
Randomly changes parameters.
End of decomposition interval.
class to manipulate complex images
Methods:
- *(number)
- *(refer object FourierImage)
- **(number)
- *=(number)
- *=(refer object FourierImage)
- +(number)
- +(refer object FourierImage)
- +=(number)
- +=(refer object FourierImage)
- -(number)
- -(refer object FourierImage)
- -=(number)
- -=(refer object FourierImage)
- /(number)
- /(refer object FourierImage)
- /=(number)
- /=(refer object FourierImage)
- AddIm(refer object Matrix, int, int)
- AddIm(refer object Vesicule)
- AddRe(refer object Matrix, int, int)
- AddRe(refer object Vesicule)
- Conjugate(void)
- FourierImage(copy)
- FourierImage(int, int)
- FourierImage(refer object MathImage)
- FourierImage(refer object MathImage, refer object MathImage)
- FourierImage(refer object String, refer object String, int, int)
- GetAmplitude(void)
- GetBitsIm(void)
- GetBitsRe(void)
- GetConjugate(void)
- GetIm(void)
- GetImValue(number, number)
- GetMatrixIn(int, int, int, int)
- GetMatrixRe(int, int, int, int)
- GetPhase(void)
- GetRe(void)
- GetReValue(number, number)
- Height(void)
- Normalize(void)
- PutImValue(number, number, number)
- PutReValue(number, number, number)
- Set(refer object FourierImage, int, int, int, int, int, int)
- SetIm(refer object MathImage)
- SetIm(refer object Matrix, int, int)
- SetIm(refer object Vesicule)
- SetRe(refer object MathImage)
- SetRe(refer object Matrix, int, int)
- SetRe(refer object Vesicule)
- SubstractIm(refer object Matrix, int, int)
- SubstractRe(refer object Matrix, int, int)
- Transform(boolean)
- Width(void)
- ~FourierImage(void)
Returns object MathImage with amplitudes of complex image self.
param Direction;
If Direction == TRUE - the method makes direct Fourier transform of image
else it makes back Fourier transform of image
The original image is replased by result of transform
Class for pasing the information about normal distribution.
#module root.mathematic
Methods:
Checks whether boundaries fit.
param Name, Value, Boundary;
Returns a sequentional list of fitting-parameter boundaries
#rus Возвращает линейный список параметров фитирования
Returns a sequentional list of fitting parameters.
Randomly changes parameters.
Randomly changes parameters.
Class is intended for passing parameters in the fitting class using
an arbitrary parametric function.
#module root.mathematic
Methods:
Creates a description of distributions based on sequentially enumerated
fitting parameters.
Class GausSpectr is intended for approximation building
of nonhomogeneously widened molecular spectrums
and light diffusion calculation.
#module root.mathematic
Methods:
- GausSpectr(refer object Vector)
- GetCPPClassSize(void)
- GetGaussSpectr(number, number)
- GetGaussSpectrDiff1(number, number)
- GetGaussSpectrDiff2(number, number)
- GetGaussSpectrDiff3(number, number)
- GetGaussSpectrDiff4(number, number)
- GetLogNormalSpectr(number, number, number)
- GetLogNormalSpectrDiff1(number, number, number)
- GetLogNormalSpectrDiff2(number, number, number)
- GetLogNormalSpectrDiff3(number, number, number)
- GetLogNormalSpectrDiff4(number, number, number)
- GetOscillatorStrength(number, number, number)
- GetScattering(number)
- GetScattering(number, number, number, number)
- GetScattering2(number, number, number, number)
- GetScattering2(number, number, number, number, number, number)
- SerializeCPPClass(void)
- UnSerializeCPPClass(refer object String)
param NuArray;
Creates an object for building curves in points specified in the NuArray array.
It is assumed, that NuArray contains frequency values.
param nu_max, delta, ro;
Returns an array Y for the gauss spectrum in points determined
by the frequency array specified in the Constructor.
Parameters of the gauss spectrum:
nu_max - maximum position
delta - half of the line-width
ro - line skew
param Nu, dNu, Ro;
Calculation of oscillator strength with maximum Nu,
half-width dNu and skew equal to Ro.
It is assumed, that the frequencies are specified in kaysers.
param alpha;
Returns an array Y for the light diffusion function nu ** alpha
in points determined by the frequency array, specified in the constructor.
param alpha0, Nu0, alpha1, Nu1;
Returns an array Y for light diffusion function
nu ** ( (alpha1 - alpha0) / (Nu1 - Nu0) * (Nu - Nu0) )
in points determined by the frequency array, specified in the constructor.
param alpha0, Nu0, alpha1, Nu1;
Returns an array Y for light diffusion function
nu ** ( a * (Nu - Nu0) ** 2 + b * (Nu - Nu0) + c )
in points determined by the frequency array, specified in the constructor.
The coefficients of the polynome are calculated from
1) the condition for passage through the points (alpha0, Nu0), (alpha1, Nu1)
2) by zero derivative at point Nu0.
param alpha0, Nu0, alpha1, Nu1, alpha2, Nu2;
Returns an array Y for light diffusion function
nu ** ( a * (Nu - Nu0) ** 2 + b * (Nu - Nu0) + c )
in points determined by the frequency array, specified in the constructor.
The coefficients of the polynome are determinedfrom the condition
for passage through the points (alpha0, Nu0), (alpha1, Nu1) and (alpha2, Nu2)
Basic class for decomposition of the spectrum into a number of nonhomogeneous
widened gauss components and Rayleigh light diffusion.
#module root.mathematic
Methods:
Decomposition of the spectrum into a number of nonhomogeneous
widened gauss components and Rayleigh light diffusion using the
gradient deescent method.
param Res;
Method returns a component array, corresponding the result Res.
param Res, X;
Method returns a component array, corresponding the result Res.
Class is intended for decomposition of the spectrum into a number of
gauss components and Rayleigh light diffusion using the gradient descent method.
#module root.mathematic
Methods:
#rus Метод вычисляет вариации и амплитуды полученных результатов
Decomposition of the spectrum into a number of nonhomogeneous
widened gauss components and Rayleigh light diffusion using the
gradient deescent method.
param index;
Prints the result of index.
param index;
Prints the result of index.
Class GimCurve is inherits the Curve and TFunc propetries of tabular functions
and contains additional fields, characteristic for the functions created with GIM.
#module root.mathematic
Methods:
- @=(refer object TFunc)
- GimCurve(number, number, int, any)
- GimCurve(number, number, number, any, object String)
- GimCurve(refer object GimCurve)
- GimCurve(refer object Vector, refer object Function)
- GimCurve(refer object Vector, refer object Function, object String)
- GimCurve(refer object Vector, refer object Vector)
- GimCurve(refer object Vector, refer object Vector, object String)
- GimCurve(void)
Constructor of an empty function.
param from, to, nsteps, Func;
Creates a tabular function, with X changing from 'from"' to 'to' with quantity
of steps equal to 'nstep' . The values of Y are determined by the values of
the 'Func' function at appropriate points.
param from, to, nstep, Func, Comment;
Creates a tabular function, with X changing from 'from"' to 'to' with quantity
of steps equal to 'nstep' . The values of Y are determined by the values of
the 'Func' function at appropriate points with a 'Comment' comment.
Copyconstructor.
param X, F;
Creates a tabular function based on X array and the F function.
param X, F, Comment;
Creates a tabular function based on X array and the F function
and a 'Comment' comment.
param X, Y;
Creates a tabular function based on X and Y vectors.
param X, Y, Comment;
Creates a tabular function based on X and Y vectors
and a 'Comment' comment.
Constructor of an empty function.
#module root.mathematic
Methods:
- ExpFunc(int, refer object Vector, refer object Vector)
- ExpFunc1(int, refer object Vector)
- FindAmplitudes(int)
- Fit(object Vector)
- GetFunc(refer object Vector, int)
- GetResidue(refer object Vector)
- GetTau(int)
- GlobExpFitting(refer object Vector, int, number, boolean)
- Jacobian(int, int, refer object Vector, refer object Vector)
- ReSelectStartPoint(object Vector, object Vector, object Vector)
- SetProgress(refer object GProgressWnd)
- SetSilent(boolean)
- ~GlobExpFitting(void)
param Curves, NumberOfAttempts, Accuracy, CheckBaseLine;
#module root.mathematic
Class is intended for decomposition of the spectrum into a number of nonhomogeneous
widened gauss components and Rayleigh light diffusion using the
gradient descent method.
Methods:
- CalculateAmplitudes(void)
- GetApproxCurve(int, int, refer object Vector)
- GetCPPClassSize(void)
- GetComponentCurve(int, int, int, refer object Vector)
- GetComponents(refer object Vector, object Vector, int)
- GlobGaussDecompose(refer object Vector, object BandListGauss)
- HasSecondarySolution(void)
- MakeDecomposition(refer ...)
- Print(int)
- Print(int, boolean)
- SerializeCPPClass(void)
- SquareDiff(refer object Vector)
- UnSerializeCPPClass(refer object String)
- _SquareDiff(refer object Vector, refer object Vector)
- ~GlobGaussDecompose(void)
#rus Метод вычисляет вариации и амплитуды полученных результатов
param Index, j, X;
Returns the approximating curve of result Index
for the curve j specified at points X.
param Index, j, X;
Returns a curve of the component j in the result Index, specified in points X.
param Res, X, index;
Method returns an array of coordinates,
corresponding with the result Res for the curve index.
Decomposition of a spectrum into a number of inhomogeneously widened
log-normal components an the Rayleigh light diffusion using
the gradient descent method.
param Result;
#rus Метод возвращает TRUE если после нахождения минимума
#rus надо произвести повторный поиск с модифицированной
#rus функцией.
Result search.
param index;
Prints result of index.
param index;
Prints result of index.
#module root.mathematic
Class is intended for decomposition of the spectrum into a number of
nonhomogeneously widened log-normal components and the Rayleigh ligt diffusion
using the gradient descent method.
Methods:
#rus Метод вычисляет вариации и амплитуды полученных результатов
param Index, j, X;
Method returns the approximating curve of result Index,
for the curve j, specified at points X.
param Index, j, X;
Returns a curve of the component j in result Index specified in points X.
param Res, X, index;
Method returns an array of components,
corresponding with the result Res for the index curve in points X.
Decomposition of the spectrum into a number of nonhopmogeneously widened
log-normal components and the Rayleigh light diffusion using the gradient
descent method.
param Result;
#rus Метод возвращает TRUE если после нахождения минимума
#rus надо произвести повторный поиск с модифицированной
#rus функцией.
Result search.
param index;
Prints result of index.
#module root.mathematic
Class for finding a minimum of a one-dimensional function
using the gold section method.
Methods:
returns the result.
param Func, Boundaries, Accuracy;
Creates a GoldSection object in order to find the minimum of an one-dimensional
function using the gold section method.
Parameters:
Func - function which becomes 2 parameters:
- variable along which the minimum is searched for.
- a help random parameter specified by calling the
SetExtraParam method.
Function must return a value which has to be minimized.
Boundaries - a pair od boundary values, determining the region
to search for the solution.
Accuracy - the accuracy of the search for the solution (search for the solution
continued until the distance between the subsequent points of approximation of
solution will be less than accuracy)
Searches for the function minimum.
#module root.mathematic
Class for wavelet image analysis.
Methods:
Returns the amount of the scale levels in Haar's image decomposition
param Level;
Returns an MathImage class object containing the details
of the decomposition with "Level" level.
Method returns an MathImage class object, obtained while reconstructing from
Haar's decomposition.
param Level;
Returns the reconstructed image (an MathImage class object)with reconstruction to depth
equal to "Level".
param Threshold;
Returns a MathImage object , obtained by reconstruction. Elements of
decomposition with absolute value less than Threshold are excluded.
param Image;
Performs a symmetric Haar decomposition of the "Image" image.
param StartLevel;
Reconstructs an image beginning with the details of 'StartLevel' level
until the maximum detalization of image. Returns a MathImage class object.
#module root.mathematic
Class Wavelet for Haar basis decomposition.
Methods:
param Curve
Performs a base Haar decomposition of the 'Curve' curve.
#module root.mathematic
Class for recovery of the position of characteristic on the sequence
from methods belonging to DotHelix class.
Offset - beginning of the characteristic.
Len - Length of characteristic.
Weight - weight (in the portions of root from the dispersion) of characteristic.
Methods:
#module root.mathematic
Class is intended to calculate the estimation of the likelihood of Hi2.
Methods:
Returns the distribution histogramm.
Returns the distribution histogramm.
param Y, k, Accuracy;
Creates a Hi2 for sample Y with k degrees of freedom.
Estimation Hi2 is the estimation of the likelihood
of the fact that Y is the sample of normal distribution with
the unknown average and unknown dispersion.
The calculation is performed with accuracy equal to 'Accuracy'
#module root.mathematic
Class Histogramm ensures the work with piecewise-constant functions.
Methods:
param x;
Returns the value of the histogramm in point x, if x does not
belong to the set of values in the table X.
param f;
Returns a tabular function which is the function which receives the message
multiplied with the tabular function f.
param f;
Multiplies the function which receives the message with f.
Returns a reference to self.
param f;
Returns a tabular function which is the function which receives the message
added to the tabular function f.
param f;
Adds the function which receives the message to f.
Returns a reference to self.
param f;
Returns a tabular function which is the function which receives the message
minus the tabular function f.
param f;
Subtracts f from the function which receives the message.
Returns a reference to self.
param f;
Returns a tabular function which is the function which receives the message
divided through the tabular function f.
param f;
Divides the function which receives the message through f.
Returns a reference to self.
Constructor for creating a histogramm from a function.
All Curve class constructors are supported.
Constructor for creating a histogramm from a function.
Constructor for creating a histogramm from a function.
param from, to;
Returns histogramms integral on section [from, to]
Returns a histogramm which is an integral of the called histogramm.
param from, to;
Returns a value being a called histogramms integral on section [from, to]
Returns a histogramm which is an integral of the called histogramm.
param X;
Returns the curve in points X.
#module root.mathematic
Basic class for decomposition of non-normalized histogramms to a sum of distribution
using the gradient descent method.
For correct work of the algorithhm the presence of a real amount of events in
the (bin) interval is essential.
Methods:
#rus Метод вычисляет вариации и амплитуды полученных результатов
#rus Метод вычисляет амплитуды полученных результатов
param Index, X;
Returns an approximated curve of the solution 'Index' specified in points X.
param Index, j, X;
Returns the curve of the component j in solution Index specified in points X.
param Index, X;
Returns an approximated curve of the solution 'Index' specified in points X.
param Index, j, X;
Returns the curve of the component j in solution Index specified in points X.
param Index, X;
#rus Возвращает аппроксимационную кривую решения Index определенную в точках X.
param Result;
Returns non-normalized result probability.
Decomposition of the histogramm to a sum of distribution
using the gradient descent method.
param Result;
#rus Метод, вычисляющий оптимизируемую функцию.
param Result;
Method calculates the function which has to be optimized.
#module root.mathematic
Class is intended for decomposition of a non-normalized histogramm
to a sum of exponents using the gradient descent method.
For correct work of the algorithhm the presence of a real amount of events in
the interval is essential.
Methods:
param index, X;
Obtains the components of components for the solution number index
at points assigned by vector X.
param Res;
Returns an array of components corresponding with the result Res.
param index, X;
Obtains the components of components for the solution number 'index'
at points assigned by vector X.
This function is implemented for optimization reason:
Tau calculation requare Exp calculation, so it is avoid to
do this calculation for every X point
#rus Метод возвращает минимальные амплитуды шагов фитирования
Decomposition of a histogramm to a sum of exponents
using the gradient descent method.
param index;
Prints out the 'index' solution.
param index;
Prints out the 'index' solution.
#module root.mathematic
Class is intended for fitting of a non-normalized histogramm
specified by a non-peremetrical distribution function.
For correct work of the algorithhm the presence of a real amount of events in
the interval is essential.
Methods:
param Index, X;
Returns an approximated curve of the solution 'Index' specified in points X.
param Index, X;
Returns an approximated curve of the solution 'Index' specified in points X.
Decomposition of the histogramm to a sum of distribution
using the gradient descent method.
param index;
Prints out the 'index' solution.
#module root.mathematic
#rus Класс предназначен для разложения ненормированной гистограммы на сумму
#rus нормальных расределений методом градиентного спуска.
#rus Для правильной работы алгоритма существенным является наличие в интервале
#rus реального количества событий.
Methods:
param index, X;
Obtains the components of components for the solution number index
at points assigned by vector X.
param Res;
Returns an array of components corresponding with the result Res.
param index, X;
Obtains the components of components for the solution number 'index'
at points assigned by vector X.
#rus Метод возвращает минимальные амплитуды шагов фитирования
Decomposition of a histogramm to a sum of
normal distributions using the gradientb descent method.
param index;
Prints out the 'index' solution.
param index;
Prints out the 'index' solution.
#module root.mathematic
Class is destined for deconvolution of non-normalized histogram on sum of
radial-symmetric normal distribution by gradient descent method. It is essential to
have in the bin the real number of counts (events).
Methods:
param index, X;
Obtains the components of components for the solution number index
at points assigned by vector X.
param Res;
Returns an array of components corresponding with the result Res.
param index, X;
Obtains the components of components for the solution number 'index'
at points assigned by vector X.
#rus Метод возвращает минимальные амплитуды шагов фитирования
Decomposition of the histogramm to a sum of radial-symmetric
normal distributions using the gradient descent method.
param index;
Print the index-th result of deconvolution
param index;
Print the index-th result of deconvolution
#module root.mathematic
Class HistogrammSurface provides basic functions for
the realization of a "2-dimensional histogramm".
It behaves like a mathematical function with 2 arguments.
Methods:
param x, z;
returns the value of Y in point (x,z)
param v;
Multiplies self with the surface v.
param v;
Multiplies self with the surface v.
param v;
Adds v to self.
param v;
Adds v to self.
param v;
Subtracts v from self.
param v;
Subtracts v from self.
param v;
Divides self through v.
param v;
Divides self through v.
Constructor creating a 2-dimensional histogramm.
For the description of parameters of the constructor
see parent class.
Constructor creating a 2-dimensional histogramm from a surface.
param a, b;
Returns a function being an integral of the called surface along X axis
in the interval (a, b). Integral is calculated using the trapezoid method.
The additive constant of indefinite integral is set equal to zero.
Returns a function being an integral of a called tabular function along X axis
in the interval (a, b). Integral is calculated using the trapezoid method.
The additive constant of indefinite integral is set equal to zero.
param a, b;
Returns a function being an integral of the called surface along Z axis
in the interval (a, b). Integral is calculated using the trapezoid method.
The additive constant of indefinite integral is set equal to zero.
Returns a function being an integral of a called tabular function along X axis
in the interval (a, b). Integral is calculated using the trapezoid method.
The additive constant of indefinite integral is set equal to zero.
Reads a surface from the FileName file.
param X, Z;
Returns a surface specified in points (X * Z).
param z;
Returns a function obtained by cutting the surface
by plane XY at point z.
param x;
Returns a function obtained by cutting the surface
by plane ZY at point x.
param index;
Returns a function xy oin index 'index' in the table.
#module root.mathematic
Class is intended for light diffusion search using the
gradient descent method.
Methods:
#rus Метод вычисляет вариации и амплитуды полученных результатов
param Res;
Returns a component array, corresponding with the result Res.
param Res, X;
Returns a component array, corresponding with the result Res.
param index;
Print the index-th result.
param Result;
Method calculating the function which has to be optimized, normalized for dispersion
#module root.mathematic
Class LineRegr2 is intended for finding a decomposition of the
goal function to basic functions using the least squares method.
Methods:
- GetCPPClassSize(void)
- GetErrors(refer object Vector)
- GetSquareDiff(refer object Vector, refer object Vector)
- GetWeights(refer object Vector)
- GetWeights(refer object Vector, refer any)
- LineRegr2(refer object Vector)
- LineRegr2(refer object Vector, number, boolean, boolean)
- LineRegr2(refer object Vector, number, number, boolean, boolean)
- LineRegr2(refer object Vector, refer object Vector)
- LineRegr2(refer object Vector, refer object Vector, number, boolean, boolean)
- LineRegr2(refer object Vector, refer object Vector, number, number, boolean, boolean)
- SerializeCPPClass(void)
- UnSerializeCPPClass(refer object String)
- ~LineRegr2(void)
param S;
Calculating the errors of weght values calculated by the
LineRegr2::GetWeights method.
S is an array of arrays of base function values.
It is assumed, that the function are specified in the same points on x and
also in the array which is passed as a parameter in the constructor and
only contains y- values (?).
Returns a vector of discomposition coefficients like:
Y = A[0] * S[0] + A[1] * S[1] + ...
param S;
Calculation of the weights of base function components
using the linear regression method.
It is assumed, that the function are specified in the same points on x and
also in the array which is passed as a parameter in the constructor and
only contains y- values (?).
Returns a vector of discomposition coefficients like:
Y = A[0] * S[0] + A[1] * S[1] + ...
param S, Residue;
Calculate the weight of the base function components using the linear regression method.
S is an array of base function value arrays.
t is assumed, that the function are specified in the same points on x and
also in the array which is passed as a parameter in the constructor and
only contains y- values (?).
Returns a vector of discomposition coefficients like:
Y = A[0] * S[0] + A[1] * S[1] + ...
The residue of hi2 is passed through the 'Residue' parameter.
param Y;
Constructor for regression of the Y array with unknown dispersion
with a search for a basic line without limiting the parameters.
param Y, MaxAmplitude, IsPositive, CheckOffset;
Constructor for regression of the Y array with unknown dispersion.
If CheckOffset == TRUE, then a base line search is performed.
If IsPositive == TRUE, then only positive results are searched for.
MaxAmplitude determines the maximum allowed amplitude of the result parameters.
param Y, Disp;
Constructor for regression of the Y array with dispersion equal to 'Disp'.
The base line search is performed without limiting the parameters.
param Y, Disp, MaxAmplitude, IsPositive, CheckOffset;
Constructor for regression of the Y array with dispersion equal to 'Disp'.
If CheckOffset == TRUE, then a base line search is performed.
If IsPositive == TRUE, then only positive results are searched for.
MaxAmplitude determines the maximum allowed amplitude of the result parameters.
Line Approximation (for any number of points)
#module root.mathematic
Methods:
Approximation calculation (spline value),
with the mu parameter lying in the interval of [0,...,1]
Finds derivation of spline at prameter mu = [0,...,1]
Line Approximation (for any number of points)
#module root.mathematic
Class Line_LSQM2 is destined to calculate
linear regression by expression
y = Sum(A[i] * f[i](x)).
Methods:
param UseDispersionFromCurve, Progress;
Calculation of linear regression.
The result of calculation can be obtained using the following methods:
GetA(i) - returns the calculated value of A[i]
GetStdDevA(i) - returns the confidence interval of A[i]
GetResidue() - returns the residue
GetApprox(from, to, n_steps) - returns the approximation
curve in the interval (from, to) on n_steps to points.
If parameter Progress == TRUE, then the window of progress is opened,
otherwise the calculation is conducted "silently".
If parameter UseDispersionFromCurve == TRUE, then it is assumed,
that the dispersion is known and is contained in field Disp
of the analyzed function, otherwise the dispersion is relied
by unknown and is evaluated.
param i;
returns calculated value of A[i]
param from, to, n_steps;
Returns an approximation curve on the (fron, to) interval on n_steps points.
param from, to, n_steps, Comment;
Returns an approximation curve on the (fron, to) interval on n_steps points.
param i, j;
Returns the correlation coefficient of A[i] and A[j] parameters.
Returns non-normalized discomposition probability value.
It can be normalized by equating the sum of the probabilities for all models to one.
Returns calculated residue value.
param i;
Returns calculated value of the confidence interval A[i]
param y;
Constructor for finding linear regressionusing the formula:
y = A * x + B
param y, f;
Constructor for finding linear regressionusing the formula:
y = Sum(A[i] * f[i](x)).
#module root.mathematic
Class for calculating the marginalization integral logarithm
on alpha from entropy prior.
Methods:
- ()(number)
- GetDerivative(number)
- GetSecondDerivative(number)
- LogIntegralI(number, number, number, number, refer object Vector)
- ~LogIntegralI(void)
#module root.mathematic
Base class for spectrum decomposition to a number of
non-homogeneously widened log-normal components and Rayleigh light diffusion.
Methods:
param Res;
Returns a component array corresponding with result Res.
param Res, X;
Returns a component array corresponding with result Res.
Spectrum decomposition to a number of
non-homogeneously widened log-normal components and Rayleigh light diffusion
using the gradient descent method.
Sets light scattering control check.
#module root.mathematic
Class for spectrum decomposition to a number of
non-homogeneously widened log-normal components and Rayleigh light diffusion
using the gradient descent method.
Methods:
#rus Метод вычисляет вариации и амплитуды полученных результатов
Spectrum decomposition to a number of
non-homogeneously widened log-normal components and Rayleigh light diffusion
using the gradient descent method.
param index;
Print the index-th result
#module root.mathematic
Class is intended to perform basic image manipulations.
Methods:
- &(refer object MathImage)
- &=(refer object MathImage)
- *=(number)
- *=(refer object MathImage)
- +(refer object MathImage)
- +=(number)
- +=(refer object MathImage)
- -(refer object MathImage)
- -=(number)
- -=(refer object MathImage)
- /=(number)
- /=(refer object MathImage)
- Add(refer object Matrix, int, int)
- Add(refer object Vesicule)
- Clear(void)
- ClipByThreshold(number)
- ClipByThresholds(number, number)
- ConvertToMask(void)
- ConvolveWithGauss(number)
- ConvolveWithMask(refer object FourierImage)
- DeleteSecondaryBuffers(void)
- Dilute(void)
- Discretize(int)
- Erode(void)
- Erosion(int)
- Expand(int)
- FindCentralLines(int)
- FindCentralLines(int, int)
- FindMaximum(int, int, int, int, int)
- FindMaximumByGrid(refer any)
- FindMinimum(int, int, int, int, int)
- FindVesicule(int, int, int, int, refer any)
- FindVesicule(refer object Vector, refer object Vector, int, int, int, int, refer any, refer any, number, boolean)
- FindVesicules(int, int, int, int, refer any, number, boolean, number, boolean)
- FitImage(int, int)
- FitVesicules(refer object Vector, int, int, int, int, refer any, boolean)
- FlipH(void)
- FlipV(void)
- Get3BytesBits(int)
- Get3BytesBits(int, refer object SimpleLUT)
- GetBits(int)
- GetBits(int, refer object SimpleLUT)
- GetCentralLines(void)
- GetCurve(number, number, number, number)
- GetGaussMask(number)
- GetHistogram(number, number, number, number)
- GetIsoPoints(int)
- GetMatrix(int, int, int, int)
- GetNonZeroPoints(void)
- GetNonZeroRect(void)
- GetNonZeroSquare(void)
- GetResidue(refer object MathImage, number, number, number)
- GetResidue(refer object MathImage, number, number, number, number, number)
- GetResidue(refer object Matrix, int, int, int)
- GetSquareOfRegion(number, number, number, number)
- GetSurface(number, number, number, number)
- GetValue(number, number)
- GetValues(refer object Vector)
- GetVector(int, int, int, int)
- Height(void)
- InitGrid(number, number)
- InitGrid(number, number, boolean)
- Integral(int, int, int, int)
- Inverse(int)
- Inverse(void)
- InverseBilevel(boolean)
- InverseBilevel(void)
- IsValid(void)
- Laplasian(void)
- LineRegression(refer object Vector, int, int, refer any)
- Load(int, object String, object String, ...)
- LoadFromFile(object String)
- MathImage(int, int)
- MathImage(int, object String)
- MathImage(int, object String, object String)
- MathImage(int, refer object String, int, int, int)
- MathImage(int, refer object String, int, int, int, int)
- MathImage(refer object MathImage, int, int, int, int)
- MathImage(refer object Matrix)
- MaximumProjection(refer object MathImage)
- Mean_SD(int, int, int, int)
- Mean_SD(int, int, int, int, int)
- MedianSmooth(int)
- MedianSmooth(int, int, int, int, int)
- MergeImage(refer object MathImage, boolean, refer ...)
- MergeImage(refer object MathImage, number, number, number, boolean)
- MergeImage(refer object MathImage, number, number, number, number, number, boolean)
- MinimumProjection(refer object MathImage)
- PutValue(number, number, number)
- ResetFittingBoundaries(void)
- ResetTransfer(void)
- SaveToFile(object String)
- SearchMergingPoint(object Vector, int, refer object MathImage, number, refer ...)
- Set(refer object MathImage)
- Set(refer object Matrix, int, int)
- Set(refer object Vesicule)
- SetFittingBoundaries(refer object Vector)
- SetPixel(int, int, int)
- SetSize(int, int)
- SetTransfer(number, number, number)
- SkipNegative(void)
- Smooth(int)
- Smooth(int, int, int, int, int)
- Smooth(int, int, int, int, int, refer object Matrix)
- Smooth(int, refer object Matrix)
- Squeeze(int)
- Substract(refer object Matrix, int, int)
- SubstractBackground(int)
- SubstractBackground(int, int)
- SubstractBackground(int, int, int, int, int)
- SubstractBackground(int, int, int, int, int, int)
- ToBilevel(int)
- ToBilevel(int, boolean)
- UpdateGrid(number, number, number, number)
- UpdateGrid(number, number, number, number, boolean)
- Width(void)
- |(refer object MathImage)
- |=(refer object MathImage)
param Img;
Returns a sum of 2 images: 'self' and 'img'.
The images must be of the same size.
param Img;
Adds 'Img' to 'self'. The images must be of the same size.
param Img;
Returns the difference of 'self' and 'Img'.
The images must be of the same size.
param Img;
Subtracts 'Img' from 'self'.
Images must be of the same size.
param Matrix, x, y;
Adds the 'Matrix' matrix to 'self'.
Matrix is added with a shift (x, y).
param Threshold_0, Threshold_1;
Method reduces to zero all intensities not belonging
to half-interval [ Threshold_0, Threshold_1).
param UpperBoundary
Implements erosion - resetting the boundary points if they are less
than UpperBoundary. Method works ONLY with the positive intensity values.
Boundaries are n-boundaries with a zero-intensity area.
Compresses the objects to their geometric center.
Method modifies its own images and does not return anything.
param N;
Method returns the image, obtained from image 'self' by tension by N times.
Implements erosion - setting the boundary points to zero if they are less than
UpperBoundary and do not form objects carcass.
Then,in order to remove the ends of the carcasses
found carcasses are enlarged by the spheres of radius 'ExpandReadius'
and erosion is repeated.
thod works ONLY with the positive intensity values.
Boundaries are n-boundaries with a zero-intensity area.
Method modifies its own images and does not return anything.
param x, y, width, height, wnd;
returns the coordinates of the maximum point in the rectangular region
(x, y, width, height).
Thereby 2*wnd + 1 is the size of a square window in which the averaging
is performed while searching the maximum.
If the search for the maximum without averaging is required , then wnd = 0.
param x, y, width, height, offset;
#rus Метод ищет везикулу в прямоугольнике (x, y, width, height) и возвращает
#rus массив найденных везикул (объекты класса Vesicule). Через параметр offset
#rus возвращается величина пъедестала в области прямоугольнике поиска
param StartPoint, Boundaries, x, y, width, height, offset, Residue;
#rus Метод ищет везикулы в прямоугольнике (x, y, width, height) и возвращает
#rus массив найденных везикул (объекты класса Vesicule).
#rus StartPoint - начальная точка поиска, по пять параметров на одну везикулу.
#rus Boundaries - границы области поиска в пространстве параметров.
#rus Через параметр offset возвращается величина пъедестала в области прямоугольнике поиска
#rus Через параметр Residue возвращается невязка.
param off_x, off_y, width, height, offset, MinSquare, CheckOffset, Threshold, EllipseBaseFunc;
#rus Метод ищет набор везикул в прямоугольнике (x, y, width, height) и возвращает
#rus массив найденных везикул (объекты класса Vesicule). Через параметр offset
#rus возвращается величина пъедестала в области прямоугольнике поиска.
#rus MinSquare - минимальная допустимая площадь везикулы
param x, y;
Returns TRUE if the point (x,y) belongs to the image considering the shift-turn
specified by the MathImage::SetTransfer method,
else returns FALSE.
param Vesicules, x, y, width, height, Residue, CheckOffset;
Returns a vesicule amplitude array; the vesicules are enumerated in the
Vesicule array while fitting the image in rectangle (x, y, width, height)with them.
The last element of the returned vector contains the size of the offset.
The residue is returned through the 'Residue' parameter.
Reflects the image specularly relative to vertical axis.
Reflects the image specularly relative to horizontal axis.
param b;
Returns image bits. If b ==1 the image is transformed to 1-byte
image if b==2 the image is transformed to a 2-byte image.
param x0, y0, x1, y1;
#rus Метод возвращает кривую яркости изображения
#rus вдоль отрезка, заданного точками (x0, y0, x1, y1)
param Level;
Method returns a coordinate pair vector <<x, y>> of image points,
having the intensity level equal to 'Level'.
param x, y, width, height;
Method returns a matrix with size equal to (height, width) filled with
image intensity values in rectangle (x, y, width, height).
Method returns a coordinate vector pair <<x, y>> opf image points
having a intensity level not equal to zero.
param Image, offset_x, offset_y, alpha;
Returns the residue while impositioning the image 'image' on 'self'
with an offset equal to (offset_x, offset_y) and a turn equal to 'alpha'.
param Image, offset_x, offset_y, alpha, intensity_offset, intensity_scale;
Returns the residue while impositioning the image 'image' on 'self'
with an offset equal to (offset_x, offset_y) and a turn equal to 'alpha'.
While calculating the residue the image intensity of 'Image' is transformed
using the formula:
I' = intensity_scale * I + intensity_offset
param Matrix, offset_x, offset_y, step;
Returns the residue while impositioning the matrix 'Matrix' on 'self'
with an offset equal to (offset_x, offset_y).
The step between the matrix points while impositioning is equal to 'Step'.
param x, y, width, height;
#rus Метод возвращает поверхность, соответствующую
#rus прямоугольнику (x, y, x + width, y + height)
#rus изображения
param x, y;
Returns the intensity in point (x, y) considering the shift-turn of
the image determined by MathImage::SetTransfer method.
param Points;
Method returns a vector of intensities in points enumerated in the 'Points' vector.
The Points vector must either contain a number of pairs << x, y >> or a number
of POINT class objects.
param x, y, width, height;
Method returns an image piece from the rectangle (x, y, width, height)
expanded to a vector line-by-line.
returns the height of the image.
param width, height;
param width, height, RelativeToVariation;
Returns TRUE if initialization of the image succeeded,
otherwise returns FALSE.
param Matrixes, x, y, Residue;
Method returns an array of the amplitudes obtained by fitting the array of
matrices with identical dimensionality in the rectangle
(x, y, Matrixes[0]->X(), Matrixes[0]->Y())
The last element of the returned vector contains the offset value.
Residue is returned through the 'Residue' parameter.
param Color, FileType, FileName, [BigEndian];
#rus Загружает изображение из файла FileName.
#rus Поскольку MathImage является серым изображением, то берется
#rus цветной байт с номером Color.
#rus Color == -1 - серый
#rus 0 - красный
#rus 1 - зеленый
#rus 2 - синий
#rus Возможные значения параметра FileType: "TIFF", "JPEG", "BMP", "GIF"
#rus Если параметр BigEndian установлен, то функция чтения 16-ти битных TIFF файлов
#rus форсируется к определенному порядку байт.
#rus Параметр введен для чтения 16-ти разрядных TIFF файлов с ошибкой в заголовке (tif_header.tiff_magic)
param width, height;
#rus Создает черное изображение размером (width x height).
Creates a black image with size (width x height).
param Color, FileName;
#rus Загружает изображение из файла FileName.
#rus Поскольку MathImage является серым изображением, то берется
#rus цветной байт с номером Color.
#rus Color == -1 - серый
#rus 0 - красный
#rus 1 - зеленый
#rus 2 - синий
param Color, FileType, FileName;
#rus Загружает изображение из файла FileName.
#rus Поскольку MathImage является серым изображением, то берется
#rus цветной байт с номером Color.
#rus Color == -1 - серый
#rus 0 - красный
#rus 1 - зеленый
#rus 2 - синий
#rus Возможные значения параметра FileType: "TIFF", "JPEG", "BMP", "GIF"
param depth, bits, offset, width, height
Creates an image from bit data.
depth - describes the structure of the bit data. Possible values:
CMID_BYTE, CMID_WORD, CMID_RGB, CMID_RGB16
bits - data
offset - offset for sign images. For unsigned images must be equal to 0.
width and height - size of the image.
Creates an image from bit data.
depth - describes the structure of the bit data. Possible values:
CMID_BYTE, CMID_WORD, CMID_RGB, CMID_RGB16
MathImage is a grey picture, so a color with the n
umber 'Color' must be taken:
Color == 0 - red
1 - green
2 - blue
bits - data
offset - offset for sign images. For unsigned images must be equal to 0.
width and height - size of the image.
param Img, x, y, width, height;
Creates an extra image from a rectangle area of 'Img'.
param Matrix;
Creates an image from the 'Matrix' matrix.
param x, y, width, height;
Returns a vector << average value, average square deviation >>
in the rectangle area specified by the following parameters:
(x, y, width, height).
param x, y, width, height, itter_number;
Returns a vector << average value, average square deviation >>
in the rectangle area specified by the following parameters:
(x, y, width, height).
The itter_number parameter specifies the iteration number while calculating
the average value. All values differing more than 2 average squaer deviations are excluded.
param wnd;
Performs a smoothing of an image with a median filter with a square window
having the size 2 * wnd + 1.
param wnd, left, top, width, height;
Performs smoothing of an image in a rectangle with the top corner (left, top)
and size equal to width x height
param Image, Transparent, [ProgressWnd];
#rus Метод возвращает сшитые изображения self и Image. Область перекрытия определяется
#rus автоматически. Если Transparent == TRUE, то область перекрытия прозрачная, иначе
#rus self накрывает Image.
#rus ProgressWnd - не обязательный параметр класса GProgressWnd для отображения прогресса
#rus поиска области перекрытия.
param Image, offset_x, offset_y, alpha, Transparent;
Method merges 2 images and returns a MathImage as a result.
The image 'Image' is thereby shifted by offset_x, offset_y) and turned by the
angle 'alpha'.
If Transparent == TRUE, images are laid on each other transparently in the overlap region,
otherwise 'self' overlaps 'Image'
param Image, offset_x, offset_y, alpha, offset, scale, Transparent;
Method merges 2 images and returns a MathImage as a result.
The image 'Image' is thereby shifted by offset_x, offset_y) and turned by the
angle 'alpha'.The intensity of the 'Image' image is converted before merging
using the formula: I' = scale * I + offset.
If Transparent == TRUE, images are laid on each other transparently in the overlap region,
otherwise 'self' overlaps 'Image'
#rus Сбрасывает предустановленные значения границы
Resets the shift-turn of the image, set by the MathImage::SetTransfer
method.
param StartPoint, NumbToTry, Image, Accuracy;
#rus Метод вычисляет параметры перекрытия изображений self и Image.
#rus Возвращает вектор << Offset_x, Offset_y, Alpha, IntensityOffset, IntensityScale >>,
#rus где Offset_x, Offset_y, Alpha - это смещение и поворот изображения Image относительно self
#rus для наилучшего наложения. IntensityOffset, IntensityScale - преобразование интенсивности
#rus изображения Image, обеспечивающее лучшее наложение.
#rus StartPoint - начальное приближение.
#rus NumbToTry - количество попыток поиска глобального оптимума
#rus Accuracy - точность вычисления.
param Matr, x, y;
Method fills the image rectangle (x, y, Matr->X(), Matr->Y())
with values from the 'Matr' matrix.
param boundaries;
#rus Устанавливает границы области поиска совмещения двух изображений
#rus Формат параметра boundaries:
<<
<< X0, X1 >>,
<< Y0, Y1 >>,
<< Alpha0, Alpha1 >>,
<< IntensityOffset0, IntensityOffset1 >>,
<< IntensityScale0, IntensityScale1 >>
>>
param offset_x, offset_y, alpha;
Sets the image offset (offset_x, offset_y) and the turn 'alpha'.
Method sets all negative values in image to zero.
param wnd;
Performs smoothing of the image with a floating average value
with a square window having the size 2 * wnd + 1.
param wnd, left, top, width, height;
Performs smoothing of the image in the rectangle with the top corner
(left, top) and size equal to width x height using the floating average value
with a square window having the size 2 * wnd + 1.
param N;
Performs N time sqeezing of the initial image pon both dimensions.
Returns a MathImage as a result.
param Matrix, x, y;
Subtracts 'Matrix' from 'self'.
The matrix is subtracted through shifting (x, y)
param wnd;
For each point an average value is calculated. Then it is subtracted using
a square window with size 2 * wnd + 1.
While calculating the average value iteratively (3 iterations)
all points with value exceeding 3 * sigma + mean are excluded.
param wnd, Rep;
For each point an average value is calculated. Then it is subtracted using
a square window with size 2 * wnd + 1.
While calculating the average value iteratively (with 'Rep' number of iterations)
all points with value exceeding 3 * sigma + mean are excluded.
param wnd, x0, y0, width, height;
For each point an average value is calculated. Then it is subtracted using
a square window with size 2 * wnd + 1. The subtraction is performed in a rectangle
(x0, y0, width, height).
While calculating the average value iteratively (3 iterations)
all points with value exceeding 3 * sigma + mean are excluded.
param wnd, x0, y0, width, height, Rep;
For each point an average value is calculated. Then it is subtracted using
a square window with size 2 * wnd + 1. The subtraction is performed in a rectangle
(x0, y0, width, height).
While calculating the average value iteratively (with 'Rep' number of iterations)
all points with value exceeding 3 * sigma + mean are excluded.
param off_x, off_y, width, height;
param off_x, off_y, width, height, RelativeToVariation;
Returns the width of the image.
#module root.mathematic
Base class for curve decomposition to a number of Michaelis components
using the gradient descent method.
Methods:
param index, X;
Gets the components of components for the solution number 'index'
in points specified by vector X.
param Res;
Retuns a component array , corresponding with the result Res.
Class for transfering the information about one spectrum line.
Methods:
Checks whether boundaries fit.
param kD, Hill, Boundaries;
#module root.mathematic
Class for decomposition of curve groups to a number of Michaelis components
using the gradient descent method.
Methods:
param index;
Prints the index-th result.
#module root.mathematic
Base class for curve decomposition to a number of Michaelis components
using the gradient descent method.
Methods:
param index;
Prints the index-th result.
Class is intended for passing the parameters in the decomposition class
to Michaels components.
The 'List' field contains a MichaelsComponent object vector.
Methods:
It is assumed, that the values of the parameters are always transferred
in concentrations
#module root.mathematic
Methods:
- ()(number)
- CalculateVariation(refer object TFunc)
- GetFunc(refer object Vector)
- GetResidue(refer object TFunc)
- GetResidue(void)
- MultiExponent(object Vector, object Vector)
- MultiExponent(object Vector, object Vector, object Vector, object Vector)
#module root.mathematic
Class is intended for solution search in non-linear equatations
using the Newton iteration method.
Methods:
#rus Возвращает результат решения системы.
param Func, Jacobian, Boundaries, StartPoint, Accuracy;
An NonLineSystem object is created for solving an equatation system
{Func[i] == 0}.
Parameters:
Func - function array building the equataion system
It is assumed, that functions receive 2 parameters:
- an array of varables in the space of which the search for
a solution is performed
- an auxiliary parameter set by the user by calling the
SetExtraParam method.
Jacobian - jacobian of the system which has to be solved (matrix,
with an element i, j being the derivative of i-th function 'Func' on
j-th variable). It is assumed, that jacobian functions receive
parameters:
- an array o variables in the space of which the solution is searched for
- an auxiliary parameter set by the user by calling the
SetExtraParam method.
- a reference to an NonLineSystem class object performing the
solution of the equatation system.
Boundaries - a boundary pair value array defining the solution search area
Startpoint - an array of starting values (initial solution search point)
Accuracy - accuracy of solution search (search for solution continues until
the distance between the subsequent approximation points is less than 'Accuracy')
This constructor is more preferable , if it is possible to assign jacobian
functions directly.
param Func, Boundaries, StartPoint, Accuracy;
#rus Создается объект NonLineSystem для решения системы уравнений
{Func[i] == 0}.
#rus Параметры:
#rus Func - массив функций, образующих систему уравнений.
#rus Предполагается, что функции получают 2 параметра:
#rus - массив переменных, в пространстве которых ищется решение.
#rus - вспомогательный параметр произвольной природы,
#rus устанавливаемый пользователем при помощи вызова
#rus метода SetExtraParam.
#rus Boundaries - массив пар граничных значений, определяющий область
#rus поиска решения.
#rus StartPoint - массив начальных значений (исходная точка поиска решения)
#rus Accuracy - точность поиска решения (поиск решения прекращается, когда
#rus расстояние между последующими точками приближения решения будет
#rus меньше Accuracy).
param Alpha;
#rus Решает систему с регуляризующим параметром Alpha.
#rus Допустимые значения параметра 0.0 < Alpha <= 1.0
#rus Если по достижениии MaxItterationNumber иттераций заданная
#rus точность решения не достигнута - поиск решения прекращается
#rus и возбуждается ошибка - ERR_SOLUTION_NOT_FOUND
#rus Решает систему.
#rus Если по достижениии MaxItterationNumber иттераций заданная
#rus точность решения не достигнута - поиск решения прекращается
#rus и возбуждается ошибка - ERR_SOLUTION_NOT_FOUND
#module root.mathematic
Class is intended for solving non-linear equatations using
section division in half method.
Methods:
Returns the result of system solution.
param Func, Boundaries, Accuracy;
#rus Создается объект NonLineSystem для решения системы уравнений
{Func[i] == 0}.
#rus Параметры:
#rus Func - левая часть ур-ния Func = 0.
#rus Предполагается, что функця получает 2 параметра:
#rus - переменная, в пространстве которых ищется решение.
#rus - вспомогательный параметр произвольной природы,
#rus устанавливаемый пользователем при помощи вызова
#rus метода SetExtraParam.
#rus Boundary - пара граничных значений, определяющая область
#rus поиска решения.
#rus Accuracy - точность поиска решения (поиск решения прекращается, когда
#rus расстояние между последующими точками приближения решения будет
#rus меньше Accuracy).
An NonLineSystem object is created for solving an equatation system
{Func[i] == 0}.
Parameters:
It is assumed, that the function receives 2 parameters:
- an array of varables in the space of which the search for
a solution is performed
- an auxiliary parameter set by the user by calling the
SetExtraParam method.
Func - the left part of the Func equatation is = 0
Boundary - a boundary pair value array defining the solution search area
Accuracy - accuracy of solution search (search for solution continues until
the distance between the subsequent approximation points is less than 'Accuracy')
Solves the system.
If MaxItterationNumber of iterations is reached,but the specified accuracy
of the solution is not achieved,the search for the solution stops,
and an ERR_SOLUTION_NOT_FOUND error is invoked.
Class is intended for parameter transfer to the histogramm decomposition class.
#module root.mathematic
Methods:
Creates a distribution description based on sequentially enumerated
fitting parameters.
Class for transfer of information about the normal distribution.
#module root.mathematic
Methods:
Checks whether boundaries fit.
Returns a sequentional list of fitting-parameter boundaries
Returns a sequentional list of fitting-parameters.
param Mean, Sigma, Amp;
param Mean, Sigma, Amp, Boundaries;
#rus Случайным образом меняет параметры
Randomly changes parameters.
#module root.mathematic
Solves the set of linear equations with the three-diagonal
matrix using the sweep method.
Methods:
param A, B, C, D, a0, b0, aN, bN;
Solution of the three-diagonal set of linear equations of
the following type:
------------------------
A[i] * y[i + 1] + B[i] * y[i] + C[i] * y[i - 1] + D[i] = 0
when i > 0 and i < N
y[0] = a0 * y[1] + b0;
when i = 0;
y[N] = aN * y[N - 1] + bN;
when i = N;
where N - the number of points of the grid on which the
solution is searched.
Note:
Set solution exists and the unique one if
-B[i] >= A[i] + C[i]
-B[i], A[i], C[i] > 0
when i > 0 and i < N
and
0 <= a0 < 1
0 <= aN < 1
Returns the equation set solution
The PointSpline class represents a dump class for the
degenerate case - an array consists of one point.
#module root.mathematic
Methods:
param mu;
Calculates the spline value when the mu parameter value
is located within the [0,...,1] interval
Calculates the derivative of spline at the mu point which
is located within the [0,...,1] interval
Methods:
param Res;
Returns a component array corresponding with the result Res.
param Result, X;
Returns a component array corresponding with the result Result in points X.
param Curve, ExpList;
param index;
Prints the index-th result.
Cubic approximation (for 4 points)
#module root.mathematic
Methods:
Approximation calculation (spline value) when the mu parameter value
is located within the [0,...,1] interval
Calculates the derivative of spline at the mu point which
is located within the [0,...,1] interval
Cubic approximation (for 4 points)
Class is intended for transfering parameters to the histogramm decomposition class.
#module root.mathematic
Methods:
Creates a description of distribution based on sequentially enumerated
fitting-parameters.
Class for transfering information about the normal distribution.
#module root.mathematic
Methods:
Checks whether boundaries fit.
Returns a sequentional list of fitting-parameter boundaries
Returns a sequentional list of fitting-parameters.
param Mean, Sigma, Amp;
param Sigma Amp, Boundaries;
#rus Случайным образом меняет параметры
Randomly changes parameters.
#module root.mathematic
The Runge is designed to solve the Cauchy set of equations
by the Runge-Kutta method of the 4-th order.
The solved set represents the system of the following type:
dy0/dx = F0(x, y0, y1, y2, ..., yn);
dy1/dx = F1(x, y0, y1, y2, ..., yn);
.........
dyn/dx = Fn(x, y0, y1, y2, ..., yn);
with starting conditions when x = x0
y0(x0) = Y0;
y1(x0) = Y1;
......
yn(x0) = Yn;
Methods:
param System, StartConditions;
Populates base structures for solving the Cauchy set of
equations by the Runge-Kutta method.
System - second members of the set of equations in the
following form F(x, << y0, ..., yN >>).
StartConditions - starting conditions listed in the same
order as the second members of equations.
In order to solve the set it is necessary to call the
SolveSystem method of the Couchy class.
Class is intended for parameter transfer to the spectrum decomposition class.
The 'List' field contains a vector of Wavelength objects.
The RefrPower field contains the degree of light-diffusion.
Methods:
Returns parameter boundaries.
Returns parameters.
Sets fitting interval.
Creates a spectrum description based on sequentially enumerated
fitting parameters.
Randomly changes parameters.
Randomly changes parameters.
Class for transfering the information about scattering.
Methods:
Checks whether boundaries fit.
param Power;
param Power, Boundary;
param Power, Boundary;
#module root.mathematic
Class Wavelet of Shoder basis decomposition.
Methods:
param Curve;
Wavelet decomposition of the 'Curve' curve using Shoder basis.
Class SimpleLUT is intended for specifying a simple LUT for exporting
the images from the MathImage class.
#module root.mathematic
Methods:
Class Vesicule
#module root.mathematic
Class for describing of vesicules on microscope images.
Methods:
param Image;
Image - vector of raw images in the different color planes
Method calculate the summ of integrals of raw image intensities
under the vesicle area.
Returns the contour of the particle.
Returns the area of the vesicule on half-height.
Returns the volume of the vesicule on half-height.
param X, Y, Width, Assymetry, Alpha;
Creates a vesicule in position (X, Y) with width equal to 'Width', assymetry
equal to 'Assymetry' and axis tension Alpha.
param X, Y, Width, Assymetry, Alpha, Amplitude;
Creates a vesicule in position (X, Y) with width equal to 'Width', assymetry
equal to 'Assymetry' and axis tension Alpha. The amplitude of the vesicule is equal
to 'Amplitude'.
param X, Y, Width, Assymetry, Alpha;
Creates a vesicule in position (X, Y) with width equal to 'Width', assymetry
equal to 'Assymetry' and axis tension Alpha.
#module root.mathematic
Parent class for iteration solving methods.
Methods:
param Object, Method;
Method sets an object-method pair for method calling after each iteration step.
Method 'Method' is called from object 'Object'.
The vector containing the current solution approximation is transfered
as a first parameter to the called method, the second parameter is a reference
to a NonLineSystem object which is solving the system.
param ExtraParam;
Method sets an auxiliary parameter ExtraParam which is transfered to functions
of the system which has to be solved.
This method must only be called if the functions of the system require an
auxiliary parameter.
param MaxItterationNumber;
Sets the maximum iteration number while searching for the solution.
If MaxItterationNumber is reached, but the specified accuracy is not achieved
the search for te solution is stopped, and an ERR_NEWTON_SOLUTION_NOT_FOUND
is invoked.
param ProgressWnd;
Sets a progress window showing the iteration number.
Allows/forbids printing the results of current iteration to standard output.
#module root.mathematic
The Spline class is a base class for spline-descendants.
A spline is a parameter function, where the parameter
vary form 0 to 1.
At that the spline values represent coordinate pairs POINT(x, y).
Methods:
param n;
Returns the control point whose number is
specified via the n parameter
Calculates the length of a curve by 50 segments
param n, v;
Changes the position of the control point whose
number is specified via the n parameter
Quadratic approximation (for 3 points)
#module root.mathematic
Methods:
Approximation calculation (spline value) when the mu parameter value
is located within the [0,...,1] interval
Calculates the derivative of spline at the mu point which
is located within the [0,...,1] interval
Quadratic approximation (for 3 points)
#module root.mathematic
Class to basic moment calculation for sample set
Methods:
Returns the variance of sample set
Returns the mean of sample set
param Data;
Creates the object Stat for sample set Data
#module root.mathematic
The StretchExp describes array elements of the StretchExpList class.
Methods:
Checks whether boundaries fit.
Methods:
param Res;
Returns a component array corresponding with the result Res.
param index;
Prints the index-th output.
param Curve, StretchExpList;
#module root.mathematic
Class StretchExpList is intended for transfering the parameters to the
BaseStretchExp class.
Methods:
RAndomly changes parameters.
Methods:
param Res;
Returns a component array corresponding with the result Res.
param index;
Prints the index-th output.
param Curve, StretchExpList;
#module root.mathematic
Finds the optimum adjustment of two character sequences
using the dynamic programming method
Methods:
#module root.mathematic
Finds the optimum adjustment of two character sequences
using the dynamic programming method
Returns the length of the best comparison.
Returns the weight of the best comparison.
This method is used for debugging purposes.
param Seq1, Seq2, GapPenalty, WeightFunction;
Finds the optimum adjustment of two character sequences
specified via the Seq1 and Seq2 parameters using the dynamic
programming method.
GapPenalty - penalty for a gap.
WeightFunction - function of two arguments of the char type which
returns the weight of two letters comparison.
param Seq1, Seq2, GapPenalty, WeightFunction;
Finds the optimum adjustment of two character sequences
specified via the Seq1 and Seq2 parameters using the dynamic
programming method.
GapPenalty - penalty for a gap.
WeightFunction - function of two arguments which compares the elements
of the arrays specified via the Seq1 and Seq2 parameters and returns
the weight of two elements comparison.
#module root.mathematic
The TFunc class executes base functions for
implementing the "table function".
That is it represents the pair of tables: X and Y,
and acts as a real arithmetic function of one argument
Methods:
- ()(number)
- *(number)
- *(refer object Function)
- **(number)
- *=(number)
- *=(refer object Function)
- +(number)
- +(refer object Function)
- +=(number)
- +=(refer object Function)
- -(number)
- -(refer object Function)
- -(void)
- -=(number)
- -=(refer object Function)
- /(number)
- /(refer object Function)
- /=(number)
- /=(refer object Function)
- @(refer object TFunc)
- @=(object TFunc)
- Align(object TFunc, boolean, boolean)
- AutoCorrelation(void)
- AverDups(void)
- Average(void)
- BSplineSmoothByPoint(int, int, int)
- BSplineSmoothByPoint(int, int, int, int)
- BackgroundByRollingBall(number)
- ChebyshevDerivativeCoeffs(object Vector)
- ChebyshevSmoothByPoint(int, int, int)
- CorrelationFunc(refer object TFunc)
- Diff(int, number)
- Diff(void)
- Diff2(void)
- DiffChebyshev(int, int)
- ExpX(void)
- GetChebyshevCoeffs(int, int, int)
- GetChebyshevPolynoms(int, int)
- GetDispersion(boolean)
- GetDispersion(void)
- HasDispersion(void)
- Index(number)
- Integral(number, number)
- Integral(void)
- IntegralSimpson(number, number)
- IntegralSimpson(void)
- InverseX(void)
- Len(void)
- LoadCommentFromFile(object String)
- LoadFromFile(object String)
- LoadSweepFromFile(object String)
- LogX(void)
- Max(void)
- MedianSmooth(int)
- MedianSmooth(int, int, int)
- Merge(object TFunc, boolean, boolean, boolean, boolean)
- Mid(int, int)
- Min(void)
- Modifyed(void)
- Remove(int, int)
- Resample(int, boolean)
- Resample(object Vector)
- Resample(object Vector, boolean)
- SaveToFile(object String)
- Scale(number)
- ScaleX(number)
- ScaleXByFunc(refer any)
- Shift(number)
- Smooth(int)
- Smooth(int, int, int)
- Smooth121(void)
- SmoothEnd(int)
- SmoothStart(int)
- TFunc(number, number, int, refer any)
- TFunc(refer object TFunc)
- TFunc(refer object Vector, refer object Function)
- TFunc(refer object Vector, refer object Vector)
- TFunc(void)
- Variation(void)
- Zero(void)
- maxX(void)
- maxY(void)
- maxYindex(void)
- minX(void)
- minY(void)
- minYindex(void)
- pos(number)
- x(int)
- y(int)
param x;
Returns the value of function in the point specified via the x
parameter. If this parameter does not belong to the range of values
specified in the X table, then the interpolation value is calculated
param dy;
Returns the table function which is produced from
the table function that received the message by multiplying
all its y values by the offset specified via the dy parameter.
param f;
Returns the table function which represents the
product of the function that received the message
and the table function specified via the f parameter
param p;
Returns the table function which is produced from
the table function that received the message by
raising all its y values to power specified via
the p parameter.
param f;
Multiplies the function that received the message by
the function specified via the f parameter. Returns
the reference to self.
param dy;
Returns the table function which is produced from
the table function that received the message by adding
the offset specified via the dy parameter to all its y values.
param f;
Returns the table function which represents the sum
of the function that received the message and the table
function specified via the f parameter
param f;
Adds the function specified via the f parameter
to the function that received the message. Returns
the reference to self.
param f;
Adds the function specified via the f parameter
to the function that received the message. Returns
the reference to self.
param dy;
Returns the table function which is produced from
the table function that received the message by subtracting
the offset specified via the dy parameter from all its y values.
param f;
Returns the table function which represents the
difference of the function that received the message
and the table function specified via the f parameter
Unary minus operator. Returns the copy of the object that received
message where all Y values are substituted with -Y values.
param n;
Subtracts from the function that received the message. Returns
the reference to self.
param f;
Subtracts the function specified via the f parameter
from the function that received the message. Returns
the reference to self.
param dy;
Returns the table function which is produced from
the table function that received the message by dividing
all its y values by the offset specified via the dy parameter.
param f;
Returns the table function which represents the
quotient from division the function that received the message
by the table function specified via the f parameter
param f;
Divides the function that received the message by
the function specified via the f parameter. Returns
the reference to self.
Combination of two curves.
Combination of two curves with offset and shift selection along X axis.
param f, Stretch, NoDispersion;
Equalizes the 'self' curve (shift and tension along X axis)
If Stretch == FALSE, than only shift is performed.
If NoDispersion == TRUE, than it is assumed, that the dispersion is unknown
and is homogen along the curve.
Return autocorrelation function
replase X-duplicates by average values
Return average value
param N, from, to;
Returns a function obtained by approximation with B-splines of 3rd order
of function in the interval (from, to). Quantity of datum points is equal
to N. Smoothing is performed in the point index space in the table.
The ends of the interval are included.
param N, from, to, k;
Returns a function obtained by approximation with B-splines of k-th order
of function in the interval (from, to). Quantity of datum points is equal
to N. Smoothing is performed in the point index space in the table.
The ends of the interval are included.
param R;
Returns a curve obtained by rolling a sphere with radius R over a "pedestal"
param coeff;
Returns an array of Chebyshev polynom coefficients for the derivative of the
function described by a number of 'coeff' Chebyshev polynom coefficients.
param N, from, to;
Returns a fucnction obtained by approximation of Chebyshev polynoms of
2nd order with degree N of the part of the function in interval
(from, to).
Smoothing is performed in the point index space in the table.
The ends of the interval are included.
Return correlation function
param N, RegParam;
Returns a table function being a derivative of N-th order of a table function
which received the message.
RegParam - regularization parameter
Returns the table function which represents the
derivative of the table function that received the message.
Returns the table function which represents the
second derivative of the table function that received the message.
param K, N;
Returns a table function bein a derivative of K-th order of the table
function which received the message.
Differentiation is performed using approximating Chebyshev polynomes
of N-th order.
#rus Потенциирует значения по оси X по основанию 10
The values along X axis are
param N, from, to;
Returns an array of Chebyshev polynom coefficients with order
N - 1
param N, len;
#rus Второй элемент (x) - массив значений аргумента в которых расчитаны полиномы.
Calculates a number of Chebyshev polynomials with following degrees:
0, 1, ... N - 1 , defined in 'len' points on a section [-1, 1]
Rturns a vector of 2 elements: << U, x >>.
First element (U) is a two-dimensional array of polynomial values, the 1st index
determines the degree of the polynomial.
The second element (x) is an array of values of the argument with which the
polynomials were calculated.
param Recalculate;
Returns teh estimation of dispersion for noised experimental function.
If Recalculate == TRUE and the estimation was saved, a recalculation is performed.
Returns an estimation of dispersion for a noised experimental function.
param x;
Returns the index in the table of the point whose X value is equal to
the value specified via the x parameter or directly precedes it. If the
x value is less than X[0], that is it is impossible to find equal or
preceding X value then -1 is returned.
param from, to;
Returns the number which represents the integral
on the [from, to] section of the table function
that received the message.
Returns the table function which represents the
integral of the table function that received the
message. The integral is calculated using the method
of trapezoids.
Additive constant of the indefinite integral is
supposed to be equal to 0.
param from, to;
Returns a value being an integral of a table function which
received the message in the [from, to] interval. Interval is calculated using
the Simpson method.
Returns a table function being an integral of a table function which received
the message. Integral is calculated using the Simpson method.
An additional constant of an indefinite integral is set equal to 0.
Inverses the values along the x axis.
Returns the number of elements in the table
Loads a comment to the curve from FileName.
Loads a curve from FileName.
Loads a sweep from FileName.
Takes the logarithm of values along X-axis using the basis 10.
Maximum of function.
Returns an object of the Vector type that contains
<<x, y>> values where the function obtains the maximum.
param p;
Returns the function which is obtained by smoothing
with median filter.
The width of the smoothing window is equal to 2 * p + 1.
param p, from, to;
Returns a function obtained by smoothing of a function part in the
interval (from, to) using the median filter.
The ends of the interval are include.
The width of the smoothing window equals 2 * p + 1.
Merges two curves (including the selection of 'pedestal'
and scaling along y axis, shift and axial stretching X).
If Scale == TRUE, the scaling coefficient is selected.
If Stretch == TRUE, the stretching for the curve f along axis X is selected.
If Offset == TRUE, an offset for the curve f along axis Y is selected.
If NoDispersion == TRUE, it is assumed, that the dispersion is unknown
and is homogeneous along the curve.
param Len, Offset;
Returns a curve which is obtained by cutting a segment from the
current curve. The length of this curve is specified via the Len
parameter, it is cut from the point specified via the Offset
parameter.
Minimum of function.
Returns an object of the Vector type that contains
<<x, y>> values where the function obtains the minimum.
Method is called if significant modification of the function occur,
leading to the need for reconstructing auxiliary fields in heir-classes
param offset, len;
Deletes the number of ponts determined via the len parameter
from a curve beginning with the position specified via the offset parameter.
param CurveLen, LogSampling;
Returns the curve with the amount of point equal to CurveLen.
If LogSampling == TRUE, x is changing homopgeneously in the logarithmic scale.
param X;
Returns the curve in points X.
param X, Approximate;
Returns the curve in points X.
Saves the curve in FileName.
Multiplies all X values by the m multiplier
Scales the X-axis
Scales the X-axis
Shifts a curve along the X axis on the dx offset.
param p;
Returns the function which is obtained by
smoothing with floating average.
The width of the smoothing window is equal to 2 * p + 1.
param p, from, to;
Returns the function which is obtained by
smoothing with floating average of the function
within the (from, to) range of point numbers.
Range ends are specified inclusively.
The width of the smoothing window is equal to 2 * p + 1.
Returns a function obtained by smoothing with weighted floating
average value with weights equal to (1, 2, 1).
param p;
Returns the function which is obtained by
smoothing the last p function points with floating
average using the variable window whose size changes
from 0 to 2 * p + 1.
* p + 1.
param p;
Returns the function which is obtained by
smoothing the first p function points with floating
average using the variable window whose size changes
from 0 to 2 * p + 1.
param from, to, nsteps, Func;
It creates the table function whose X changes from the 'from'
parameter to the 'to' parameter, the number of steps is equal to
the 'nsteps' parameter, and the Y values are determined by the 'Func'
function in the appropriate points.
This constructor is designed to create a copy
param X, F;
The table function is created on basis of the X array
and the function specified via the F parameter.
param X, Y;
The table function is created on basis of the X and Y array
Constructor of an empty function
Return variance value
Finds all function zeros.
Returns an object of the Vector type that contains X
values where the function is equal to zero.
Returns the maximum X value
Returns the maximum Y value
Returns the index of the maximum Y value.
Returns the minimum X value
Returns the minimum Y value.
Returns the index of the minimum Y value.
param x;
Returns the position (index) of the point which is the
nearest to the point specified via the x parameter.
param index;
Returns the x value which index in the table is specified via
the index parameter.
param index;
Returns the y value which index in the table is specified via
the index parameter.
#module root.mathematic
The TSurface class executes base functions for
implementing the "two-dimensional table function".
It acts as a real arithmetic function of two arguments.
Methods:
- ()(number, number)
- *(number)
- *(refer object TSurface)
- **(number)
- *=(number)
- *=(refer object TSurface)
- +(number)
- +(refer object TSurface)
- +=(number)
- +=(refer object TSurface)
- -(number)
- -(refer object TSurface)
- -=(number)
- -=(refer object TSurface)
- /(refer object TSurface)
- /=(refer object TSurface)
- BSplineSmoothByPoint(int, int, int, int, int, int)
- ChebyshevSmoothByPoint(int, int, int, int, int, int)
- Cut(int, int, int, int)
- DiffX(int, number)
- DiffZ(int, number)
- IndexX(number)
- IndexZ(number)
- IntegralX(number, number)
- IntegralX(void)
- IntegralZ(number, number)
- IntegralZ(void)
- LenX(void)
- LenZ(void)
- LoadFromFile(object String)
- MedianSmooth(int, int)
- MedianSmooth(int, int, int, int, int, int)
- Resample(int, int, boolean, boolean)
- Resample(object Vector, object Vector)
- Resample(object Vector, object Vector, boolean)
- SaveToFile(object String)
- SectionXY(number)
- SectionZY(number)
- ShiftX(number)
- ShiftZ(number)
- Smooth(int, int)
- Smooth(int, int, int, int, int, int)
- TSurface(number, number, int, number, number, int, refer any)
- TSurface(refer object HistogramSurface, boolean)
- TSurface(refer object Vector, refer object Vector)
- TSurface(refer object Vector, refer object Vector, refer object Vector)
- maxY(void)
- maxZ(void)
- minY(void)
- minZ(void)
- xy(int)
- y(int, int)
- z(int)
param x, z;
Returns the Y value in the (x,z) point
param v;
Multiplies Y by the number specified via the v parameter
param v;
Multiplies self by the surface specified via the v parameter
param v;
Raises a surface to the power specified via the v parameter.
param v;
Multiplies Y by the number specified via the v parameter
param v;
Multiplies self by the surface specified via the v parameter
param v;
Adds the number specified via the v parameter to Y
param v;
Adds the surface specified via the v parameter to self
param v;
Adds the number specified via the v parameter to Y
param v;
Adds the surface specified via the v parameter to self
param v;
Subtracts the number specified via the v parameter from Y
param v;
Subtracts the surface specified via the v parameter from self
param v;
Subtracts the number specified via the v parameter from Y
param v;
Subtracts the surface specified via the v parameter from self
param v;
Divides self by the surface specified via the v parameter
param v;
Divides self by the surface specified via the v parameter
param w_x, w_z, x_start, x_end, z_start, z_end;
Returns a function obtained by smoothing using the B-spline of 3rd degree
with control points p_x, p_z in a rectangle specified by indexes
x_start, x_end, z_start, z_end.
param w_x, w_z, x_start, x_end, z_start, z_end;
#rus Возвращает функцию, полченную сглаживанием полиномами Чебышева
#rus степеней p_x, p_z
#rus в прямоугольнике определяемыми индексами
x_start, x_end, z_start, z_end.
Returns a function obtained by smoothing using Chebyshev
polinomials of degrees p_x, p_z in a rectangle specified by indexes
x_start, x_end, z_start, z_end.
param offset_x, w_x, offset_z, w_z;
Returns a function obtained by cutting the rectangle with size w_x * w_z,
located at point (offset_x, offset_z)
param N, RegParam;
Returns a function being a derivative of N-th order of function for
which the method is called on variable X.
RegParam - regularization parameter - a value in interval [0,1]
param N, RegParam;
Returns a function being a derivative of N-th order of function for
which the method is called on variable X.
RegParam - regularization parameter - a value in interval [0,1]
param x;
Returns the index of the point in table which has
the value X equal to x or is the direct predecessor of x.
If the value of x is less than X[0], that means there is no
predecessor for X, it returns -1.
param z;
Returns the index of the point in table which has
the value Z equal to z or is the direct predecessor of z.
If the value of z is less than Z[0], that means there is no
predecessor for Z, it returns -1.
param a, b;
Returns the function being the integral of the surface which became the message
on X-axis in interval (a,b). Integral is calculated using the trapezoid method.
The additional constant of the indefinite integral is set equal to 0.
Returns the function being the integral of the surface which became the message
on X-axis in interval (a,b). Integral is calculated using the trapezoid method.
The additional constant of the indefinite integral is set equal to 0.
param a, b;
Returns the function being the integral of the surface which became the message
on Z-axis in interval (a,b). Integral is calculated using the trapezoid method.
The additional constant of the indefinite integral is set equal to 0.
Returns the function being the integral of the surface which became the message
on Z-axis in interval (a,b). Integral is calculated using the trapezoid method.
The additional constant of the indefinite integral is set equal to 0.
Returns the amount of the elements in table elong X-axis
Returns the amount of the elements in table elong Z-axis
Loads a surface from FileName
param w_x, w_z;
Returns the function, obtained by smoothing using the median filter.
The width of the smoothing window is equal to (2 * w_x + 1) x (2 * w_z + 1).
param w_x, w_z, x_start, x_end, z_start, z_end;
Returns the function, obtained by smoothing using the median filter
in a rectangle with indexes x_start, x_end, z_start, z_end.
The width of the smoothing window is equal to (2 * w_x + 1) x (2 * w_z + 1).
param X_Len, Z_Len, , LogSampling_X, LogSampling_Z;
Returns a surface with an amount of points (X_Len * Z_Len).
If LogSampling_X == TRUE, X changes homogeneously in a logarithmic scale.
If LogSampling_Z == TRUE, Z changes homogeneously in a logarithmic scale.
param X, Z;
Returns a surface defined in points (X * Z).
param X, Z, Approximate;
Returns a surface defined in points (X * Z).
Saves the surface to FileName.
param z;
Returns the function which is obtained as the surface
section of the XY plane in the point specified via
the z parameter.
param x;
Returns the function which is obtained as the surface
section of the XY plane in the point specified via
the z parameter.
param dx;
Shifts a function along the X axis on the dx offset.
param dz;
Shifts a function along the Z axis on the dz offset.
param w_x, w_z;
Returns a function obtained by smoothing with a sliding window.
The length of smoothing window equals (2 * w_x + 1) x (2 * w_z + 1).
param w_x, w_z, x_start, x_end, z_start, z_end;
#rus Возвращает функцию, полченную сглаживанием плавающим окном в
#rus прямоугольнике определяемыми индексами
x_start, x_end, z_start, z_end.
#rus Ширина окна сглаживания равна (2 * w_x + 1) x (2 * w_z + 1).
Returns a function obtained by smoothing with a sliding window in
a rectangle, with indexes x_start, x_end, z_start, z_end.
The length of smoothing window equals (2 * w_x + 1) x (2 * w_z + 1).
param Zfrom, Zto, ZnSteps, XFrom, XTo, XnSteps, F;
This constructor is designed to create a two-dimensional
table function.
Where:
Zfrom, Zto, ZnSteps - sets the initial and the points
by the Z axis, and the number of points in the table by Z.
Xfrom, Xto, XnSteps - sets the initial and the points
by the Z axis, and the number of points in the table by X.
F - function of two elements or a constant.
Constructor for creating of a 2-dimensional surface from a histogramm.
param Z, F;
This constructor is designed to create a two-dimensional
table function.
Z parameter - vector of Z coordinate values for which the
curves of the section parallel to XY plane are determined.
F parameter - vector of curves (TFunc class objects) which
represent the surface sections by the planes parallel to XY
according the appropriate Z values.
param X, Y, Z;
This constructor is designed to create a two-dimensional
table function.
X parameter - vector of X coordinate values
Y parameter - two-dimensional vector of Y values
Z parameter - vector of Z coordinate values
Returns the maximum Y value
Returns the maximum Z value.
Returns the minimum Y value.
Returns the minimum Z value.
param i, j;
Returns a reference to y in the point with the following indexes:
i, j - (x, z)
param i, j;
Returns a reference to y in the point with the following indexes:
i, j - (x, z)
param index;
Returns the z value whose index within the table is
specified via the index parameter.
4-th order polynomial approximation (for 5 points)
#module root.mathematic
Methods:
Approximation calculation (spline value) when the mu parameter value
is located within the [0,...,1] interval
Calculates the derivative of spline at the mu point which
is located within the [0,...,1] interval
4-th order polynomial approximation (for 5 points)
Class Vesicule
#module root.mathematic
Class for describing of vesicules on microscopic images.
Methods:
- *=(number)
- -(pointer object POINT)
- -(pointer object Vesicule)
- -(refer object POINT)
- -(refer object Vesicule)
- Convolve(refer object ComplexVesicule)
- Convolve(refer object Vesicule)
- FindRawImageIntegral(refer object Vector)
- GetColocalization(refer object Vesicule, boolean)
- GetContour(void)
- GetIntensity(void)
- GetMatrix(number, number, number, number, int)
- GetMatrix(object RECT)
- GetMaximumIntensity(void)
- GetParameters(void)
- GetRange(void)
- GetSize(void)
- GetSquare(number)
- GetSquare(void)
- GetSurface(int, int, int, int)
- GetSurface(refer object RECT)
- GetVolume(void)
- IsColocalized(number, refer object Vesicule, boolean)
- IsOverlapping(number, refer object Vesicule)
- Scale(number)
- Shift(number, number)
- TransformCoordinate(number, number, number)
- Vesicule(number, number, number, number, number)
- Vesicule(number, number, number, number, number, number)
- Vesicule(refer object Vesicule)
param v;
Method returns an POINT object, being a vector connecting the centres of vesiculae.
param v;
Method returns an POINT object, being a vector connecting the centres of vesiculae.
param v;
Method returns an POINT object, being a vector connecting the centres of vesiculae.
param v;
Method returns an POINT object, being a vector connecting the centres of vesiculae.
Returns a convolution of vesicules.
param Ves;
Returns a convolution of vesicules.
param Image;
Image - vector of raw images in the different color planes
Method calculate the summ of integrals of raw image intensities
under the vesicle area.
param Ves, Symmetric;
Returns the relative area of vesiculae overlapping.
If Symmetric == TRUE the relative area is calculated symmetrically
(s1 & s2) / min(s1, s2), otherwise s1 & s2) / s1.
Returns the particle contour.
param x, y, width, height, step;
returns a Matrix class object obtained from intensities of the vesicule in
the rectangle (x, y, width, height) with step equal to 'step'.
Returns a number of parameters, defining Vesicule.
Returns a square containing the vesicule.
param I;
Returns the area of the vesicule on height equal to I.
Returns the area of the vesicule on half-height.
param x, y, width, height;
#rus Возвращает поверхность (объект класса TSurface), полученную из интенсивностей везикулы в
#rus прямоугольнике (x, y, width, height).
Returns a TSurface class object, obtained from intensities of the vesicule
in rectangle (x, y, width, height).
param rect;
Returns a Tsurface class object, obtained from
vesicule intensities in the rectangle 'rect'
Returns the volume of the vesicule.
param Threshold, Ves, Symmetric;
Returns TRUE if vesiculae are collocalized more than 'Threshold'.
If Symmetric == TRUE. symmetric collocalization is calculated,
else - assymetrical collocalization.
param Ves;
Returns true if vesiculae overlap each other.
param scale;
Scales the geometric size of the vesicule.
param dx, dy;
Shifts vesicule by (dx, dy);
param X, Y, Width, Assymetry, Alpha;
Creates a vesicule in position (X, Y) with width equal to 'Width' and assymetry
'Assymetry' and tension in Alpha-axis.
param X, Y, Width, Assymetry, Alpha, Amplitude;
Creates a vesicule in position (X, Y) with width equal to 'Width' and assymetry
'Assymetry' and tension in Alpha-axis. Amplitude of the vesicule equals to 'Amplitude'
param v;
Creates a copy of a vesicule.
Class VisObject
#module root.mathematic
Basic Class for describing objects on a microscopic image.
Methods:
Class for transfering information about one spectrum band.
#module root.mathematic
Methods:
- CheckBoundaries(void)
- GetBoundaries(void)
- GetParams(void)
- IsWaveLength(boolean)
- ShakeData(number, number, number)
- ShakeData(void)
- WaveLength(boolean)
- WaveLength(number, number, boolean)
- WaveLength(number, number, number, boolean)
- WaveLength(number, number, number, object Vector, boolean)
- WaveLength(number, number, object Vector, boolean)
- WaveLength(void)
#rus Проверяет соответсвие границам
Checks whether boundaries fit.
Returns a sequential list of fitting-parameter boundaries.
Returns a sequentional list of fitting-parameters.
Sets the type of the IsWaveLength parameter.
Randomly changes parameters.
Randomly changes parameters.
param Freq, Width;
param Freq, Width, Skew;
param Freq, Width, Skew, Boundaries;
param Freq, Width, Boundaries;
#module root.mathematic
Basic class for wavelet curve decomposition.
Methods:
param Level;
returns a curve with a level of wavelet-decomposition equal to 'Level'
param Level;
Returns a detalization curve with wavelet-decomposition level equal to 'Level'
Returns the amount of wavelet decomposition levels.
Returns full vector with details.
param Err;
Returns a curve with rounding less or equal to Err.
param Level;
Returns a detalization curve beginning with the wavelet-decomposition level equal
to 'Level'.
param Curve;
Builds a decomposition of 'Curve'
#rus Функция вычисления интеграла ошибок
param Color, FileName;
#rus Загружает изображение из файла FileName.
#rus Возвращает массив из 4-х изображений типа MathImage - << среднее по цветам, красное, зеленое, синее >>
param len, format, [value];
Press for creating a table printout.
Len - field length
format - print format
value - index of values which have to be printed
- *, method of class Curve
- *, method of class Histogram
- *, method of class HistogramSurface
- *, method of class TFunc
- *, method of class TSurface
- **, method of class Curve
- **, method of class TFunc
- **, method of class TSurface
- *=, method of class Curve
- *=, method of class Histogram
- *=, method of class HistogramSurface
- *=, method of class TFunc
- *=, method of class TSurface
- +, method of class Curve
- +, method of class Histogram
- +, method of class HistogramSurface
- +, method of class MathImage
- +, method of class TFunc
- +, method of class TSurface
- +=, method of class Curve
- +=, method of class Histogram
- +=, method of class HistogramSurface
- +=, method of class MathImage
- +=, method of class TFunc
- +=, method of class TSurface
- -, method of class Curve
- -, method of class Histogram
- -, method of class HistogramSurface
- -, method of class MathImage
- -, method of class TFunc
- -, method of class TSurface
- -, method of class Vesicule
- -=, method of class Curve
- -=, method of class Histogram
- -=, method of class HistogramSurface
- -=, method of class MathImage
- -=, method of class TFunc
- -=, method of class TSurface
- /, method of class Curve
- /, method of class Histogram
- /, method of class HistogramSurface
- /, method of class TFunc
- /, method of class TSurface
- /=, method of class Curve
- /=, method of class Histogram
- /=, method of class HistogramSurface
- /=, method of class TFunc
- /=, method of class TSurface
- @, method of class TFunc
- @=, method of class GimCurve
- @=, method of class TFunc
- [], method of class Cauchy
- _SquareDiff, method of class Decompose
- _SquareDiff, method of class DecomposeGlobal
- _SquareDiff, method of class DecomposeSingle
- _SquareDiff, method of class HistogramDecompose
- Adams, class
- Adams, method of class Adams
- Add, method of class MathImage
- AddFixedResult, method of class Decompose
- AddResult, method of class Decompose
- Align, method of class TFunc
- AllowProgress, method of class Cauchy
- Amplitude, method of class FFT
- ArrangeResult, method of class Decompose
- AutoCorrelation, method of class TFunc
- Average, method of class TFunc
- AverDups, method of class TFunc
- BackgroundByRollingBall, method of class TFunc
- BandList, class
- BandListGauss, class
- BaseExp, class
- BaseStretchExp, class
- BetaBlend, method of class BetaSpline
- BetaBlendDeriv, method of class BetaSpline
- BetaContour, class
- BetaContour, method of class BetaContour
- BetaCurve, class
- BetaCurve, method of class BetaCurve
- BetaSpline, class
- BlindExpDecompose, class
- BlindExpDecompose, method of class BlindExpDecompose
- BlindGaussDecompose, class
- BlindGaussDecompose, method of class BlindGaussDecompose
- BlindGlobalGaussDecompose, class
- BlindGlobalGaussDecompose, method of class BlindGlobalGaussDecompose
- BlindGlobExpDecompose, class
- BlindGlobExpDecompose, method of class BlindGlobExpDecompose
- BoundDiff2, class
- BoundDiff2, method of class BoundDiff2
- , method of class BSplineApprox
- BSplineApprox, method of class BSplineApprox
- , method of class BSplineApprox_2D
- BSplineApprox_2D, method of class BSplineApprox_2D
- BSplineApproxEx, class
- BSplineApproxEx, method of class BSplineApproxEx
- BSplineSmoothByPoint, method of class TFunc
- BSplineSmoothByPoint, method of class TSurface
- CalculateAmplitudes, method of class Decompose
- CalculateAmplitudes, method of class DecomposeGlobal
- CalculateAmplitudes, method of class DecomposeSingle
- CalculateAmplitudes, method of class GaussDecompose
- CalculateAmplitudes, method of class GlobGaussDecompose
- CalculateAmplitudes, method of class GlobLogNormalDecompose
- CalculateAmplitudes, method of class HistogramDecompose
- CalculateAmplitudes, method of class LightScattering
- CalculateAmplitudes, method of class LogNormalDecompose
- cast_from_Vesicule, method of class SimpleVesicule
- Cauchy, class
- Cauchy, method of class Cauchy
- ChebyshevDerivativeCoeffs, method of class TFunc
- ChebyshevSmoothByPoint, method of class TFunc
- ChebyshevSmoothByPoint, method of class TSurface
- CheckBoundaries, method of class BandList
- CheckBoundaries, method of class ExpDistribution
- CheckBoundaries, method of class ExpTauItem
- CheckBoundaries, method of class FitParams
- CheckBoundaries, method of class FreeParam
- CheckBoundaries, method of class MichaelsComponent
- CheckBoundaries, method of class NormalDistribution
- CheckBoundaries, method of class RadialNormalDistribution
- CheckBoundaries, method of class Scattering
- CheckBoundaries, method of class StretchExp
- CheckBoundaries, method of class WaveLength
- CheckPointPosition, method of class BetaContour
- Climb, class
- Climb, method of class Climb
- ClimbDouble, class
- ClipByThresholds, method of class MathImage
- Complex, class
- ComplexVesicule, class
- ConcateOmegaPos, method of class ExpMEM
- Convolve, method of class ComplexVesicule
- Convolve, method of class Vesicule
- CorrelationFunc, method of class TFunc
- Curve, class
- Curve, method of class Curve
- Cut, method of class TSurface
- Decompose, class
- DecomposeGlobal, class
- DecomposeGlobal, method of class DecomposeGlobal
- DecomposeResult, class
- DecomposeResult, method of class DecomposeResult
- DecomposeSingle, class
- DecomposeSingle, method of class DecomposeSingle
- Derivative, method of class BSplineApprox
- DerivativeX, method of class BSplineApprox_2D
- DerivativeXZ, method of class BSplineApprox_2D
- DerivativeZ, method of class BSplineApprox_2D
- Diff, method of class TFunc
- Diff2, method of class TFunc
- DiffChebyshev, method of class TFunc
- DiffX, method of class TSurface
- DiffZ, method of class TSurface
- Disp, method of class Stat
- DoIt, method of class Line_LSQM2
- DotHelix, class
- DotHelix, method of class DotHelix
- Erosion, method of class MathImage
- ErrorFunc, function
- ExpAlpha, class
- Expand, method of class MathImage
- ExpDistribution, class
- ExpDistribution, method of class ExpDistribution
- ExpDistrList, class
- ExpFitting, class
- ExpGlobal, class
- ExpGlobal, method of class ExpGlobal
- ExpMEM, class
- ExpMEM, method of class ExpMEM
- ExpMEMEx, class
- ExpMEMEx, method of class ExpMEMEx
- ExpSingle, class
- ExpSingle, method of class ExpSingle
- ExpTauItem, class
- ExpTauItemList, class
- ExpX, method of class TFunc
- FFT, class
- FFT, method of class FFT
- FindAccurate, method of class DotHelix
- FindCentralLines, method of class MathImage
- FindCrossection, method of class BetaCurve
- FindMaximum, method of class MathImage
- FindOmegaPos, method of class ExpMEM
- FindRawImageIntegral, method of class SimpleVesicule
- FindRawImageIntegral, method of class Vesicule
- FindRough, method of class DotHelix
- FindVesicule, method of class MathImage
- FindVesicules, method of class MathImage
- FitImage, method of class MathImage
- FitParams, class
- FitVesicules, method of class MathImage
- FlipH, method of class MathImage
- FlipV, method of class MathImage
- FourierImage, class
- FreeParam, class
- FreeParam, method of class FreeParam
- FreeParamList, class
- From, method of class FitParams
- Gauss, class
- Gauss, method of class Gauss
- GaussDecompose, class
- GaussDecompose, method of class GaussDecompose
- GausSpectr, class
- GausSpectr, method of class GausSpectr
- GetA, method of class Line_LSQM2
- GetAmplitude, method of class FourierImage
- GetAmplitudes, method of class Decompose
- GetAmplitudes, method of class DecomposeSingle
- GetAmplitudes, method of class HistogramDecompose
- GetAmplitudeVariation, method of class Decompose
- GetApprox, method of class Line_LSQM2
- GetApproxCurve, method of class DecomposeGlobal
- GetApproxCurve, method of class DecomposeSingle
- GetApproxCurve, method of class GlobGaussDecompose
- GetApproxCurve, method of class GlobLogNormalDecompose
- GetApproxCurve, method of class HistogramDecompose
- GetApproxCurve, method of class HistogramFreeFormDecomp
- GetApproximation, method of class ExpMEM
- GetApproximation, method of class ExpMEMEx
- GetBasePoints, method of class BetaContour
- GetBasePoints, method of class BetaCurve
- GetBestPath, method of class StringFitting
- GetBestPathLen, method of class StringFitting
- GetBestWeight, method of class StringFitting
- GetBits, method of class MathImage
- GetBoundaries, method of class BandList
- GetBoundaries, method of class BandListGauss
- GetBoundaries, method of class ExpDistribution
- GetBoundaries, method of class FitParams
- GetBoundaries, method of class FreeParam
- GetBoundaries, method of class NormalDistribution
- GetBoundaries, method of class RadialNormalDistribution
- GetBoundaries, method of class ScattParam
- GetBoundaries, method of class WaveLength
- GetChebyshevCoeffs, method of class TFunc
- GetChebyshevPolynoms, method of class TFunc
- GetColocalization, method of class Vesicule
- GetComponentCurve, method of class DecomposeGlobal
- GetComponentCurve, method of class DecomposeSingle
- GetComponentCurve, method of class GlobGaussDecompose
- GetComponentCurve, method of class GlobLogNormalDecompose
- GetComponentCurve, method of class HistogramDecompose
- GetComponents, method of class Decompose
- GetComponents, method of class ExpGlobal
- GetComponents, method of class ExpSingle
- GetComponents, method of class Gauss
- GetComponents, method of class GlobGaussDecompose
- GetComponents, method of class GlobLogNormalDecompose
- GetComponents, method of class HistogramExpDecompose
- GetComponents, method of class HistogramGaussDecompose
- GetComponents, method of class HistogramRadialGaussDecompose
- GetComponents, method of class LightScattering
- GetComponents, method of class LogNormal
- GetComponents, method of class Michaels
- GetComponents, method of class PoissonSingle
- GetComponents, method of class StretchExpGlobal
- GetComponents, method of class StretchExpSingle
- GetContour, method of class BetaContour
- GetContour, method of class BetaCurve
- GetContour, method of class SimpleVesicule
- GetContour, method of class Vesicule
- GetControl, method of class BetaContour
- GetControl, method of class BetaCurve
- GetControl, method of class Spline
- GetControlNumber, method of class BetaCurve
- GetControlPoints, method of class BetaContour
- GetCorrelation, method of class Line_LSQM2
- GetCurve, method of class MathImage
- GetCurve, method of class Wavelet
- GetCurveDetail, method of class Wavelet
- GetDensityApproxCurve, method of class HistogramDecompose
- GetDensityApproxCurve, method of class HistogramFreeFormDecomp
- GetDensityComponentCurve, method of class HistogramDecompose
- GetDensityComponents, method of class HistogramExpDecompose
- GetDensityComponents, method of class HistogramGaussDecompose
- GetDensityComponents, method of class HistogramRadialGaussDecompose
- GetDepth, method of class HaarImage
- GetDepth, method of class Wavelet
- GetDerivation, method of class LineSpline
- GetDerivation, method of class PointSpline
- GetDerivation, method of class QubicSpline
- GetDerivation, method of class SquareSpline
- GetDerivation, method of class TetraSpline
- GetDetail, method of class HaarImage
- GetDetailSet, method of class Wavelet
- GetDispersion, method of class Curve
- GetDispersion, method of class TFunc
- GetDistribution, method of class ExpMEM
- GetDistribution, method of class ExpMEMEx
- GetDistribution, method of class HistogramDecompose
- GetDistribution, method of class HistogramExpDecompose
- GetErrors, method of class LineRegr2
- GetFitResidue, method of class ExpMEM
- GetFitResidue, method of class ExpMEMEx
- GetHaarImage, method of class HaarImage
- GetHistogram, method of class Hi2
- GetInfo, method of class Curve
- GetIsoPoints, method of class MathImage
- GetLength, method of class Spline
- GetLogNormalSpectr, method of class GausSpectr
- GetLogProb, method of class Climb
- GetLogProb, method of class Line_LSQM2
- GetMatrix, method of class MathImage
- GetMatrix, method of class Vesicule
- GetMEMResidue, method of class ExpMEM
- GetMEMResidue, method of class ExpMEMEx
- GetMinStep, method of class Decompose
- GetMinStep, method of class HistogramExpDecompose
- GetMinStep, method of class HistogramGaussDecompose
- GetMinStep, method of class HistogramRadialGaussDecompose
- GetMonteCarlo, method of class ExpMEM
- GetNonZeroPoints, method of class MathImage
- GetNumbComponents, method of class FitParams
- GetNumberSteps, method of class Cauchy
- GetNumbItterations, method of class FitParams
- GetNumbPoints, method of class Decompose
- GetNumbPoints, method of class DecomposeGlobal
- GetNumbPoints, method of class DecomposeSingle
- GetNumbResults, method of class FitParams
- GetOffsetCurve, method of class DecomposeGlobal
- GetOffsetCurve, method of class DecomposeSingle
- GetOscillatorStrength, method of class GausSpectr
- GetParameters, method of class Vesicule
- GetParams, method of class BandList
- GetParams, method of class BandListGauss
- GetParams, method of class ExpDistribution
- GetParams, method of class FitParams
- GetParams, method of class FreeParam
- GetParams, method of class NormalDistribution
- GetParams, method of class RadialNormalDistribution
- GetParams, method of class ScattParam
- GetParams, method of class WaveLength
- GetPDF, method of class Hi2
- GetProbability, method of class Decompose
- GetProbability, method of class HistogramDecompose
- GetRange, method of class Vesicule
- GetRawDistribution, method of class ExpMEM
- GetRawDistribution, method of class ExpMEMEx
- GetRect, method of class BetaCurve
- GetRelativeArgument, method of class BSplineApprox
- GetRelativeArgument, method of class BSplineApprox_2D
- GetRelativeArgument, method of class BSplineApproxEx
- GetRelativeArgumentAndStretch, method of class BSplineApprox
- GetRelativeArgumentAndStretch, method of class BSplineApprox_2D
- GetRelativeArgumentAndStretch, method of class BSplineApproxEx
- GetResidue, method of class Line_LSQM2
- GetResidue, method of class MathImage
- GetResult, method of class Climb
- GetResult, method of class GoldSection
- GetResult, method of class NonLinearEquation
- GetResult, method of class NonLineSystem
- GetScaledImage, method of class HaarImage
- GetScattering, method of class GausSpectr
- GetScattering2, method of class GausSpectr
- GetSmoothCurve, method of class Wavelet
- GetSmoothImage, method of class HaarImage
- GetSquare, method of class ComplexVesicule
- GetSquare, method of class SimpleVesicule
- GetSquare, method of class Vesicule
- GetStdDevA, method of class Line_LSQM2
- GetSurface, method of class MathImage
- GetSurface, method of class Vesicule
- GetTangent, method of class BetaContour
- GetTangent, method of class BetaCurve
- GetValue, method of class MathImage
- GetValues, method of class MathImage
- GetVector, method of class MathImage
- GetVolume, method of class ComplexVesicule
- GetVolume, method of class SimpleVesicule
- GetVolume, method of class Vesicule
- GetWeights, method of class LineRegr2
- GetXYRanges, method of class BetaCurve
- GetXYZRanges, method of class BetaCurve
- GimCurve, class
- GimCurve, method of class GimCurve
- GlobExpFitting, class
- GlobExpFitting, method of class GlobExpFitting
- GlobGaussDecompose, class
- GlobGaussDecompose, method of class GlobGaussDecompose
- GlobLogNormalDecompose, class
- GlobLogNormalDecompose, method of class GlobLogNormalDecompose
- GoldSection, class
- GoldSection, method of class GoldSection
- HaarImage, class
- HaarImage, method of class HaarImage
- HaarWavelet, class
- HaarWavelet, method of class HaarWavelet
- HasSecondarySolution, method of class Decompose
- HasSecondarySolution, method of class GlobGaussDecompose
- HasSecondarySolution, method of class GlobLogNormalDecompose
- Height, method of class MathImage
- Helix, class
- Hi2, class
- Hi2, method of class Hi2
- , method of class Histogram
- Histogram, method of class Histogram
- HistogramDecompose, class
- HistogramDecompose, method of class HistogramDecompose
- HistogramExpDecompose, class
- HistogramExpDecompose, method of class HistogramExpDecompose
- HistogramFreeFormDecomp, class
- HistogramFreeFormDecomp, method of class HistogramFreeFormDecomp
- HistogramGaussDecompose, class
- HistogramGaussDecompose, method of class HistogramGaussDecompose
- HistogramRadialGaussDecompose, class
- HistogramRadialGaussDecompose, method of class HistogramRadialGaussDecompose
- HistogramSurface, class
- HistogramSurface, method of class HistogramSurface
- Im, method of class FFT
- Index, method of class TFunc
- IndexX, method of class TSurface
- IndexZ, method of class TSurface
- Init, method of class BetaCurve
- Init, method of class FFT
- InitAppServer, method of class ExpMEMEx
- InitGrid, method of class MathImage
- InitKinetics, method of class ExpMEMEx
- Integral, method of class Histogram
- Integral, method of class TFunc
- IntegralSimpson, method of class Histogram
- IntegralSimpson, method of class TFunc
- IntegralX, method of class HistogramSurface
- IntegralX, method of class TSurface
- IntegralZ, method of class HistogramSurface
- IntegralZ, method of class TSurface
- InverseX, method of class TFunc
- IsColocalized, method of class Vesicule
- IsOverlapping, method of class Vesicule
- IsValid, method of class MathImage
- IsWaveLength, method of class WaveLength
- Len, method of class DotHelix
- Len, method of class TFunc
- LenX, method of class TSurface
- LenZ, method of class TSurface
- LightScattering, class
- Line_LSQM2, class
- Line_LSQM2, method of class Line_LSQM2
- LineRegr2, class
- LineRegr2, method of class LineRegr2
- LineRegression, method of class MathImage
- , method of class LineSpline
- LineSpline, method of class LineSpline
- Load, method of class MathImage
- LoadCommentFromFile, method of class TFunc
- LoadFromFile, method of class HistogramSurface
- LoadFromFile, method of class TFunc
- LoadFromFile, method of class TSurface
- LoadSweepFromFile, method of class TFunc
- LogIntegralI, class
- LogNormal, class
- LogNormal, method of class LogNormal
- LogNormalDecompose, class
- LogNormalDecompose, method of class LogNormalDecompose
- LogX, method of class TFunc
- MakeDecomposition, method of class BlindExpDecompose
- MakeDecomposition, method of class BlindGaussDecompose
- MakeDecomposition, method of class BlindGlobalGaussDecompose
- MakeDecomposition, method of class BlindGlobExpDecompose
- MakeDecomposition, method of class Decompose
- MakeDecomposition, method of class GlobGaussDecompose
- MakeDecomposition, method of class GlobLogNormalDecompose
- MakeInterpolation, method of class BetaContour
- MakeInterpolation, method of class BetaCurve
- MakeSplineFromControl, method of class BetaContour
- MathImage, class
- MathImage, method of class MathImage
- MathImage::LoadImageSet, function
- Max, method of class TFunc
- maxX, method of class TFunc
- maxY, method of class TFunc
- maxY, method of class TSurface
- maxYindex, method of class TFunc
- maxZ, method of class TSurface
- Mean, method of class Stat
- Mean_SD, method of class MathImage
- MedianSmooth, method of class MathImage
- MedianSmooth, method of class TFunc
- MedianSmooth, method of class TSurface
- Merge, method of class TFunc
- MergeImage, method of class MathImage
- Michaels, class
- MichaelsComponent, class
- MichaelsComponent, method of class MichaelsComponent
- MichaelsDecompGlobal, class
- MichaelsDecompSingle, class
- MichaelsList, class
- Mid, method of class Curve
- Mid, method of class TFunc
- Min, method of class TFunc
- minX, method of class TFunc
- minY, method of class TFunc
- minY, method of class TSurface
- minYindex, method of class TFunc
- minZ, method of class TSurface
- Modifyed, method of class Curve
- Modifyed, method of class TFunc
- MonteCarlo, method of class ExpMEM
- MultiExponent, class
- NonLinearEquation, class
- NonLinearEquation, method of class NonLinearEquation
- NonLineSystem, class
- NonLineSystem, method of class NonLineSystem
- NormalDistribution, class
- NormalDistribution, method of class NormalDistribution
- NormalDistrList, class
- Pass3Diagonal, class
- Pass3Diagonal, method of class Pass3Diagonal
- Phase, method of class FFT
- , method of class PointSpline
- PoissonSingle, class
- PoissonSingle, method of class PoissonSingle
- pos, method of class TFunc
- Print, method of class DecomposeSingle
- Print, method of class ExpGlobal
- Print, method of class ExpMEM
- Print, method of class ExpMEMEx
- Print, method of class ExpSingle
- Print, method of class GaussDecompose
- Print, method of class GlobGaussDecompose
- Print, method of class GlobLogNormalDecompose
- Print, method of class HistogramExpDecompose
- Print, method of class HistogramFreeFormDecomp
- Print, method of class HistogramGaussDecompose
- Print, method of class HistogramRadialGaussDecompose
- Print, method of class LightScattering
- Print, method of class LogNormalDecompose
- Print, method of class MichaelsDecompGlobal
- Print, method of class MichaelsDecompSingle
- Print, method of class PoissonSingle
- Print, method of class StretchExpGlobal
- Print, method of class StretchExpSingle
- PrintBestPath, method of class StringFitting
- PrintInFixedField, function
- QubicSpline, class
- QubicSpline, method of class QubicSpline
- QubicSpline, method of class TetraSpline
- RadialNormalDistribution, class
- RadialNormalDistribution, method of class RadialNormalDistribution
- RadialNormalDistrList, class
- Re, method of class FFT
- Rebuild, method of class BetaContour
- Rebuild, method of class BetaCurve
- ReconstructDetail, method of class HaarImage
- ReconstructDetail, method of class Wavelet
- Remove, method of class Curve
- Remove, method of class TFunc
- Resample, method of class Histogram
- Resample, method of class HistogramSurface
- Resample, method of class TFunc
- Resample, method of class TSurface
- ResetFittingBoundaries, method of class MathImage
- ResetTransfer, method of class MathImage
- Runge, class
- Runge, method of class Runge
- SaveToFile, method of class TFunc
- SaveToFile, method of class TSurface
- Scale, method of class TFunc
- Scale, method of class Vesicule
- ScaleDispersion, method of class Curve
- ScaleX, method of class TFunc
- ScaleXByFunc, method of class TFunc
- Scattering, class
- Scattering, method of class Scattering
- ScattParam, class
- SchauderWavelet, class
- SchauderWavelet, method of class SchauderWavelet
- SearchMergingPoint, method of class MathImage
- SecondDerivative, method of class BSplineApprox
- SecondDerivativeX, method of class BSplineApprox_2D
- SecondDerivativeZ, method of class BSplineApprox_2D
- SectionXY, method of class HistogramSurface
- SectionXY, method of class TSurface
- SectionZY, method of class HistogramSurface
- SectionZY, method of class TSurface
- Set, method of class MathImage
- SetApproximateAlpha, method of class ExpMEM
- SetApproximateAlpha, method of class ExpMEMEx
- SetAutomaticFindOmegaPos, method of class ExpMEM
- SetCallback, method of class SolveByItteration
- SetCheckScattering, method of class LogNormal
- SetControl, method of class BetaContour
- SetControl, method of class BetaCurve
- SetControl, method of class Spline
- SetDeriv2Func, method of class Climb
- SetDerivFunc, method of class Climb
- SetErrorIfMaxItterNumberExceed, method of class Climb
- SetExtraParam, method of class SolveByItteration
- SetFitOmega, method of class ExpMEM
- SetFitOmega, method of class ExpMEMEx
- SetFitOmegaPos, method of class ExpMEM
- SetFittingBoundaries, method of class MathImage
- SetFittingInterval, method of class BandList
- SetFittingInterval, method of class ScattParam
- SetFixedOmega, method of class ExpMEM
- SetFixedOmega, method of class ExpMEMEx
- SetGradFunc, method of class Climb
- SetInfo, method of class Curve
- SetMaxItterationNumber, method of class SolveByItteration
- SetMaxRealtiveStepNorm, method of class Climb
- SetMaxStep, method of class Climb
- SetMinStep, method of class Climb
- SetOmegaBoundaries, method of class ExpMEMEx
- SetOmegaPos, method of class ExpMEM
- SetParams, method of class BandList
- SetParams, method of class BandListGauss
- SetParams, method of class ExpDistrList
- SetParams, method of class FitParams
- SetParams, method of class FreeParamList
- SetParams, method of class MichaelsList
- SetParams, method of class NormalDistrList
- SetParams, method of class RadialNormalDistrList
- SetParams, method of class ScattParam
- SetParentWnd, method of class Decompose
- SetPositive, method of class Decompose
- SetProgressWnd, method of class SolveByItteration
- SetSearchStartAmp, method of class ExpMEM
- SetSelectedDirectionsFunc, method of class Climb
- SetShift, method of class DotHelix
- SetSilent, method of class SolveByItteration
- SetSkewTension, method of class BetaCurve
- SetStartNumberPointsOnDecade, method of class ExpMEM
- SetStartNumberPointsOnDecade, method of class ExpMEMEx
- SetStartPoint, method of class Climb
- SetTransfer, method of class MathImage
- SetYNames, method of class Cauchy
- ShakeData, method of class BandList
- ShakeData, method of class ExpDistribution
- ShakeData, method of class ExpTauItemList
- ShakeData, method of class FitParams
- ShakeData, method of class FreeParam
- ShakeData, method of class NormalDistribution
- ShakeData, method of class RadialNormalDistribution
- ShakeData, method of class ScattParam
- ShakeData, method of class StretchExpList
- ShakeData, method of class WaveLength
- Shift, method of class ComplexVesicule
- Shift, method of class TFunc
- Shift, method of class Vesicule
- ShiftX, method of class TSurface
- ShiftZ, method of class TSurface
- SimpleLUT, class
- SimpleVesicule, class
- SimpleVesicule, method of class SimpleVesicule
- SimulateCurve, method of class ExpMEM
- SimulateCurve, method of class ExpMEMEx
- SkipNegative, method of class MathImage
- Smooth, method of class MathImage
- Smooth, method of class TFunc
- Smooth, method of class TSurface
- Smooth121, method of class TFunc
- SmoothEnd, method of class TFunc
- SmoothStart, method of class TFunc
- Solution, method of class BoundDiff2
- Solution, method of class Pass3Diagonal
- Solve, method of class Climb
- Solve, method of class ExpMEM
- Solve, method of class ExpMEMEx
- Solve, method of class GoldSection
- Solve, method of class NonLinearEquation
- SolveBFGS, method of class Climb
- SolveByCoord, method of class Climb
- SolveByItteration, class
- SolveBySelectedDirections, method of class Climb
- SolveDFP, method of class Climb
- SolveDynamic, method of class Climb
- SolvePowell, method of class Climb
- SolveSystem, method of class Cauchy
- SolveSystem, method of class NonLineSystem
- Spectr, method of class FFT
- Spline, class
- SplitVesicule, method of class ComplexVesicule
- SquareDiff, method of class Decompose
- SquareDiff, method of class DecomposeGlobal
- SquareDiff, method of class DecomposeSingle
- SquareDiff, method of class HistogramDecompose
- SquareDiff, method of class LightScattering
- SquareSpline, class
- SquareSpline, method of class SquareSpline
- Squeeze, method of class MathImage
- Stat, class
- Stat, method of class Stat
- StretchExp, class
- StretchExpGlobal, class
- StretchExpGlobal, method of class StretchExpGlobal
- StretchExpList, class
- StretchExpSingle, class
- StretchExpSingle, method of class StretchExpSingle
- StringFitting, class
- StringFitting, method of class StringFitting
- Substract, method of class MathImage
- SubstractBackground, method of class MathImage
- , method of class TetraSpline
- TFunc, class
- TFunc, method of class TFunc
- To, method of class FitParams
- Transform, method of class FourierImage
- TSurface, class
- TSurface, method of class TSurface
- UpdateGrid, method of class MathImage
- Variation, method of class TFunc
- Vesicule, class
- Vesicule, method of class Vesicule
- VisObject, class
- WaveLength, class
- WaveLength, method of class WaveLength
- Wavelet, class
- Wavelet, method of class Wavelet
- Width, method of class MathImage
- x, method of class TFunc
- xy, method of class HistogramSurface
- xy, method of class TSurface
- y, method of class TFunc
- y, method of class TSurface
- z, method of class TSurface
- Zero, method of class TFunc