timo.menzel
/
test_pie
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
test_pie/external/alglib-3.16.0/solvers.h

3718 lines
150 KiB
C
Raw Permalink Normal View History

Add texturemerge code.
2023-09-14 11:12:02 +02:00
/*************************************************************************
ALGLIB 3.16.0 (source code generated 2019-12-19)
Copyright (c) Sergey Bochkanov (ALGLIB project).
>>> SOURCE LICENSE >>>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation (www.fsf.org); either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
A copy of the GNU General Public License is available at
http://www.fsf.org/licensing/licenses
>>> END OF LICENSE >>>
*************************************************************************/
#ifndef _solvers_pkg_h
#define _solvers_pkg_h
#include "ap.h"
#include "alglibinternal.h"
#include "alglibmisc.h"
#include "linalg.h"
/////////////////////////////////////////////////////////////////////////
//
// THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (DATATYPES)
//
/////////////////////////////////////////////////////////////////////////
namespace alglib_impl
{
#if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
typedef struct
{
double r1;
double rinf;
} densesolverreport;
typedef struct
{
double r2;
ae_matrix cx;
ae_int_t n;
ae_int_t k;
} densesolverlsreport;
#endif
#if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
typedef struct
{
normestimatorstate nes;
ae_vector rx;
ae_vector b;
ae_int_t n;
ae_int_t m;
ae_int_t prectype;
ae_vector ui;
ae_vector uip1;
ae_vector vi;
ae_vector vip1;
ae_vector omegai;
ae_vector omegaip1;
double alphai;
double alphaip1;
double betai;
double betaip1;
double phibari;
double phibarip1;
double phii;
double rhobari;
double rhobarip1;
double rhoi;
double ci;
double si;
double theta;
double lambdai;
ae_vector d;
double anorm;
double bnorm2;
double dnorm;
double r2;
ae_vector x;
ae_vector mv;
ae_vector mtv;
double epsa;
double epsb;
double epsc;
ae_int_t maxits;
ae_bool xrep;
ae_bool xupdated;
ae_bool needmv;
ae_bool needmtv;
ae_bool needmv2;
ae_bool needvmv;
ae_bool needprec;
ae_int_t repiterationscount;
ae_int_t repnmv;
ae_int_t repterminationtype;
ae_bool running;
ae_bool userterminationneeded;
ae_vector tmpd;
ae_vector tmpx;
rcommstate rstate;
} linlsqrstate;
typedef struct
{
ae_int_t iterationscount;
ae_int_t nmv;
ae_int_t terminationtype;
} linlsqrreport;
#endif
#if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
typedef struct
{
double maxerr;
} polynomialsolverreport;
#endif
#if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
typedef struct
{
ae_int_t n;
ae_int_t m;
double epsf;
ae_int_t maxits;
ae_bool xrep;
double stpmax;
ae_vector x;
double f;
ae_vector fi;
ae_matrix j;
ae_bool needf;
ae_bool needfij;
ae_bool xupdated;
rcommstate rstate;
ae_int_t repiterationscount;
ae_int_t repnfunc;
ae_int_t repnjac;
ae_int_t repterminationtype;
ae_vector xbase;
double fbase;
double fprev;
ae_vector candstep;
ae_vector rightpart;
ae_vector cgbuf;
} nleqstate;
typedef struct
{
ae_int_t iterationscount;
ae_int_t nfunc;
ae_int_t njac;
ae_int_t terminationtype;
} nleqreport;
#endif
#if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
typedef struct
{
ae_int_t terminationtype;
} sparsesolverreport;
#endif
#if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
typedef struct
{
ae_vector rx;
ae_vector b;
ae_int_t n;
ae_int_t prectype;
ae_vector cx;
ae_vector cr;
ae_vector cz;
ae_vector p;
ae_vector r;
ae_vector z;
double alpha;
double beta;
double r2;
double meritfunction;
ae_vector x;
ae_vector mv;
ae_vector pv;
double vmv;
ae_vector startx;
double epsf;
ae_int_t maxits;
ae_int_t itsbeforerestart;
ae_int_t itsbeforerupdate;
ae_bool xrep;
ae_bool xupdated;
ae_bool needmv;
ae_bool needmtv;
ae_bool needmv2;
ae_bool needvmv;
ae_bool needprec;
ae_int_t repiterationscount;
ae_int_t repnmv;
ae_int_t repterminationtype;
ae_bool running;
ae_vector tmpd;
rcommstate rstate;
} lincgstate;
typedef struct
{
ae_int_t iterationscount;
ae_int_t nmv;
ae_int_t terminationtype;
double r2;
} lincgreport;
#endif
}
/////////////////////////////////////////////////////////////////////////
//
// THIS SECTION CONTAINS C++ INTERFACE
//
/////////////////////////////////////////////////////////////////////////
namespace alglib
{
#if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
*************************************************************************/
class _densesolverreport_owner
{
public:
_densesolverreport_owner();
_densesolverreport_owner(const _densesolverreport_owner &rhs);
_densesolverreport_owner& operator=(const _densesolverreport_owner &rhs);
virtual ~_densesolverreport_owner();
alglib_impl::densesolverreport* c_ptr();
alglib_impl::densesolverreport* c_ptr() const;
protected:
alglib_impl::densesolverreport *p_struct;
};
class densesolverreport : public _densesolverreport_owner
{
public:
densesolverreport();
densesolverreport(const densesolverreport &rhs);
densesolverreport& operator=(const densesolverreport &rhs);
virtual ~densesolverreport();
double &r1;
double &rinf;
};
/*************************************************************************
*************************************************************************/
class _densesolverlsreport_owner
{
public:
_densesolverlsreport_owner();
_densesolverlsreport_owner(const _densesolverlsreport_owner &rhs);
_densesolverlsreport_owner& operator=(const _densesolverlsreport_owner &rhs);
virtual ~_densesolverlsreport_owner();
alglib_impl::densesolverlsreport* c_ptr();
alglib_impl::densesolverlsreport* c_ptr() const;
protected:
alglib_impl::densesolverlsreport *p_struct;
};
class densesolverlsreport : public _densesolverlsreport_owner
{
public:
densesolverlsreport();
densesolverlsreport(const densesolverlsreport &rhs);
densesolverlsreport& operator=(const densesolverlsreport &rhs);
virtual ~densesolverlsreport();
double &r2;
real_2d_array cx;
ae_int_t &n;
ae_int_t &k;
};
#endif
#if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
This object stores state of the LinLSQR method.
You should use ALGLIB functions to work with this object.
*************************************************************************/
class _linlsqrstate_owner
{
public:
_linlsqrstate_owner();
_linlsqrstate_owner(const _linlsqrstate_owner &rhs);
_linlsqrstate_owner& operator=(const _linlsqrstate_owner &rhs);
virtual ~_linlsqrstate_owner();
alglib_impl::linlsqrstate* c_ptr();
alglib_impl::linlsqrstate* c_ptr() const;
protected:
alglib_impl::linlsqrstate *p_struct;
};
class linlsqrstate : public _linlsqrstate_owner
{
public:
linlsqrstate();
linlsqrstate(const linlsqrstate &rhs);
linlsqrstate& operator=(const linlsqrstate &rhs);
virtual ~linlsqrstate();
};
/*************************************************************************
*************************************************************************/
class _linlsqrreport_owner
{
public:
_linlsqrreport_owner();
_linlsqrreport_owner(const _linlsqrreport_owner &rhs);
_linlsqrreport_owner& operator=(const _linlsqrreport_owner &rhs);
virtual ~_linlsqrreport_owner();
alglib_impl::linlsqrreport* c_ptr();
alglib_impl::linlsqrreport* c_ptr() const;
protected:
alglib_impl::linlsqrreport *p_struct;
};
class linlsqrreport : public _linlsqrreport_owner
{
public:
linlsqrreport();
linlsqrreport(const linlsqrreport &rhs);
linlsqrreport& operator=(const linlsqrreport &rhs);
virtual ~linlsqrreport();
ae_int_t &iterationscount;
ae_int_t &nmv;
ae_int_t &terminationtype;
};
#endif
#if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
*************************************************************************/
class _polynomialsolverreport_owner
{
public:
_polynomialsolverreport_owner();
_polynomialsolverreport_owner(const _polynomialsolverreport_owner &rhs);
_polynomialsolverreport_owner& operator=(const _polynomialsolverreport_owner &rhs);
virtual ~_polynomialsolverreport_owner();
alglib_impl::polynomialsolverreport* c_ptr();
alglib_impl::polynomialsolverreport* c_ptr() const;
protected:
alglib_impl::polynomialsolverreport *p_struct;
};
class polynomialsolverreport : public _polynomialsolverreport_owner
{
public:
polynomialsolverreport();
polynomialsolverreport(const polynomialsolverreport &rhs);
polynomialsolverreport& operator=(const polynomialsolverreport &rhs);
virtual ~polynomialsolverreport();
double &maxerr;
};
#endif
#if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
*************************************************************************/
class _nleqstate_owner
{
public:
_nleqstate_owner();
_nleqstate_owner(const _nleqstate_owner &rhs);
_nleqstate_owner& operator=(const _nleqstate_owner &rhs);
virtual ~_nleqstate_owner();
alglib_impl::nleqstate* c_ptr();
alglib_impl::nleqstate* c_ptr() const;
protected:
alglib_impl::nleqstate *p_struct;
};
class nleqstate : public _nleqstate_owner
{
public:
nleqstate();
nleqstate(const nleqstate &rhs);
nleqstate& operator=(const nleqstate &rhs);
virtual ~nleqstate();
ae_bool &needf;
ae_bool &needfij;
ae_bool &xupdated;
double &f;
real_1d_array fi;
real_2d_array j;
real_1d_array x;
};
/*************************************************************************
*************************************************************************/
class _nleqreport_owner
{
public:
_nleqreport_owner();
_nleqreport_owner(const _nleqreport_owner &rhs);
_nleqreport_owner& operator=(const _nleqreport_owner &rhs);
virtual ~_nleqreport_owner();
alglib_impl::nleqreport* c_ptr();
alglib_impl::nleqreport* c_ptr() const;
protected:
alglib_impl::nleqreport *p_struct;
};
class nleqreport : public _nleqreport_owner
{
public:
nleqreport();
nleqreport(const nleqreport &rhs);
nleqreport& operator=(const nleqreport &rhs);
virtual ~nleqreport();
ae_int_t &iterationscount;
ae_int_t &nfunc;
ae_int_t &njac;
ae_int_t &terminationtype;
};
#endif
#if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
This structure is a sparse solver report.
Following fields can be accessed by users:
*************************************************************************/
class _sparsesolverreport_owner
{
public:
_sparsesolverreport_owner();
_sparsesolverreport_owner(const _sparsesolverreport_owner &rhs);
_sparsesolverreport_owner& operator=(const _sparsesolverreport_owner &rhs);
virtual ~_sparsesolverreport_owner();
alglib_impl::sparsesolverreport* c_ptr();
alglib_impl::sparsesolverreport* c_ptr() const;
protected:
alglib_impl::sparsesolverreport *p_struct;
};
class sparsesolverreport : public _sparsesolverreport_owner
{
public:
sparsesolverreport();
sparsesolverreport(const sparsesolverreport &rhs);
sparsesolverreport& operator=(const sparsesolverreport &rhs);
virtual ~sparsesolverreport();
ae_int_t &terminationtype;
};
#endif
#if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
This object stores state of the linear CG method.
You should use ALGLIB functions to work with this object.
Never try to access its fields directly!
*************************************************************************/
class _lincgstate_owner
{
public:
_lincgstate_owner();
_lincgstate_owner(const _lincgstate_owner &rhs);
_lincgstate_owner& operator=(const _lincgstate_owner &rhs);
virtual ~_lincgstate_owner();
alglib_impl::lincgstate* c_ptr();
alglib_impl::lincgstate* c_ptr() const;
protected:
alglib_impl::lincgstate *p_struct;
};
class lincgstate : public _lincgstate_owner
{
public:
lincgstate();
lincgstate(const lincgstate &rhs);
lincgstate& operator=(const lincgstate &rhs);
virtual ~lincgstate();
};
/*************************************************************************
*************************************************************************/
class _lincgreport_owner
{
public:
_lincgreport_owner();
_lincgreport_owner(const _lincgreport_owner &rhs);
_lincgreport_owner& operator=(const _lincgreport_owner &rhs);
virtual ~_lincgreport_owner();
alglib_impl::lincgreport* c_ptr();
alglib_impl::lincgreport* c_ptr() const;
protected:
alglib_impl::lincgreport *p_struct;
};
class lincgreport : public _lincgreport_owner
{
public:
lincgreport();
lincgreport(const lincgreport &rhs);
lincgreport& operator=(const lincgreport &rhs);
virtual ~lincgreport();
ae_int_t &iterationscount;
ae_int_t &nmv;
ae_int_t &terminationtype;
double &r2;
};
#endif
#if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
Dense solver for A*x=b with N*N real matrix A and N*1 real vectorx x and
b. This is "slow-but-feature rich" version of the linear solver. Faster
version is RMatrixSolveFast() function.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* iterative refinement
* O(N^3) complexity
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system
! and performs iterative refinement, which results in
! significant performance penalty when compared with "fast"
! version which just performs LU decomposition and calls
! triangular solver.
!
! This performance penalty is especially visible in the
! multithreaded mode, because both condition number estimation
! and iterative refinement are inherently sequential
! calculations. It is also very significant on small matrices.
!
! Thus, if you need high performance and if you are pretty sure
! that your system is well conditioned, we strongly recommend
! you to use faster solver, RMatrixSolveFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void rmatrixsolve(const real_2d_array &a, const ae_int_t n, const real_1d_array &b, ae_int_t &info, densesolverreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
This subroutine solves a system A*x=b, where A is NxN non-denegerate
real matrix, x and b are vectors. This is a "fast" version of linear
solver which does NOT provide any additional functions like condition
number estimation or iterative refinement.
Algorithm features:
* efficient algorithm O(N^3) complexity
* no performance overhead from additional functionality
If you need condition number estimation or iterative refinement, use more
feature-rich version - RMatrixSolve().
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
* -1 N<=0 was passed
* 1 task is solved
B - array[N]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 16.03.2015 by Bochkanov Sergey
*************************************************************************/
void rmatrixsolvefast(const real_2d_array &a, const ae_int_t n, const real_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
Similar to RMatrixSolve() but solves task with multiple right parts (where
b and x are NxM matrices). This is "slow-but-robust" version of linear
solver with additional functionality like condition number estimation.
There also exists faster version - RMatrixSolveMFast().
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* optional iterative refinement
* O(N^3+M*N^2) complexity
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system
! and performs iterative refinement, which results in
! significant performance penalty when compared with "fast"
! version which just performs LU decomposition and calls
! triangular solver.
!
! This performance penalty is especially visible in the
! multithreaded mode, because both condition number estimation
! and iterative refinement are inherently sequential
! calculations. It also very significant on small matrices.
!
! Thus, if you need high performance and if you are pretty sure
! that your system is well conditioned, we strongly recommend
! you to use faster solver, RMatrixSolveMFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
RFS - iterative refinement switch:
* True - refinement is used.
Less performance, more precision.
* False - refinement is not used.
More performance, less precision.
OUTPUT PARAMETERS
Info - return code:
* -3 A is ill conditioned or singular.
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void rmatrixsolvem(const real_2d_array &a, const ae_int_t n, const real_2d_array &b, const ae_int_t m, const bool rfs, ae_int_t &info, densesolverreport &rep, real_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
Similar to RMatrixSolve() but solves task with multiple right parts (where
b and x are NxM matrices). This is "fast" version of linear solver which
does NOT offer additional functions like condition number estimation or
iterative refinement.
Algorithm features:
* O(N^3+M*N^2) complexity
* no additional functionality, highest performance
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
RFS - iterative refinement switch:
* True - refinement is used.
Less performance, more precision.
* False - refinement is not used.
More performance, less precision.
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
B - array[N]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void rmatrixsolvemfast(const real_2d_array &a, const ae_int_t n, const real_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
This subroutine solves a system A*x=b, where A is NxN non-denegerate
real matrix given by its LU decomposition, x and b are real vectors. This
is "slow-but-robust" version of the linear LU-based solver. Faster version
is RMatrixLUSolveFast() function.
Algorithm features:
* automatic detection of degenerate cases
* O(N^2) complexity
* condition number estimation
No iterative refinement is provided because exact form of original matrix
is not known to subroutine. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in 10-15x performance penalty when compared
! with "fast" version which just calls triangular solver.
!
! This performance penalty is insignificant when compared with
! cost of large LU decomposition. However, if you call this
! function many times for the same left side, this overhead
! BECOMES significant. It also becomes significant for small-
! scale problems.
!
! In such cases we strongly recommend you to use faster solver,
! RMatrixLUSolveFast() function.
INPUT PARAMETERS
LUA - array[N,N], LU decomposition, RMatrixLU result
P - array[N], pivots array, RMatrixLU result
N - size of A
B - array[N], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void rmatrixlusolve(const real_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const real_1d_array &b, ae_int_t &info, densesolverreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
This subroutine solves a system A*x=b, where A is NxN non-denegerate
real matrix given by its LU decomposition, x and b are real vectors. This
is "fast-without-any-checks" version of the linear LU-based solver. Slower
but more robust version is RMatrixLUSolve() function.
Algorithm features:
* O(N^2) complexity
* fast algorithm without ANY additional checks, just triangular solver
INPUT PARAMETERS
LUA - array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
P - array[0..N-1], pivots array, RMatrixLU result
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved
B - array[N]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 18.03.2015 by Bochkanov Sergey
*************************************************************************/
void rmatrixlusolvefast(const real_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const real_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
Similar to RMatrixLUSolve() but solves task with multiple right parts
(where b and x are NxM matrices). This is "robust-but-slow" version of
LU-based solver which performs additional checks for non-degeneracy of
inputs (condition number estimation). If you need best performance, use
"fast-without-any-checks" version, RMatrixLUSolveMFast().
Algorithm features:
* automatic detection of degenerate cases
* O(M*N^2) complexity
* condition number estimation
No iterative refinement is provided because exact form of original matrix
is not known to subroutine. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just calls triangular
! solver.
!
! This performance penalty is especially apparent when you use
! ALGLIB parallel capabilities (condition number estimation is
! inherently sequential). It also becomes significant for
! small-scale problems.
!
! In such cases we strongly recommend you to use faster solver,
! RMatrixLUSolveMFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
LUA - array[N,N], LU decomposition, RMatrixLU result
P - array[N], pivots array, RMatrixLU result
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N,M], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void rmatrixlusolvem(const real_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const real_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, real_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
Similar to RMatrixLUSolve() but solves task with multiple right parts,
where b and x are NxM matrices. This is "fast-without-any-checks" version
of LU-based solver. It does not estimate condition number of a system,
so it is extremely fast. If you need better detection of near-degenerate
cases, use RMatrixLUSolveM() function.
Algorithm features:
* O(M*N^2) complexity
* fast algorithm without ANY additional checks, just triangular solver
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS:
LUA - array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
P - array[0..N-1], pivots array, RMatrixLU result
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS:
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
* -1 N<=0 was passed
* 1 task is solved
B - array[N,M]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 18.03.2015 by Bochkanov Sergey
*************************************************************************/
void rmatrixlusolvemfast(const real_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const real_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
This subroutine solves a system A*x=b, where BOTH ORIGINAL A AND ITS
LU DECOMPOSITION ARE KNOWN. You can use it if for some reasons you have
both A and its LU decomposition.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* iterative refinement
* O(N^2) complexity
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
LUA - array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
P - array[0..N-1], pivots array, RMatrixLU result
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void rmatrixmixedsolve(const real_2d_array &a, const real_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const real_1d_array &b, ae_int_t &info, densesolverreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
Similar to RMatrixMixedSolve() but solves task with multiple right parts
(where b and x are NxM matrices).
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* iterative refinement
* O(M*N^2) complexity
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
LUA - array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
P - array[0..N-1], pivots array, RMatrixLU result
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N,M], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void rmatrixmixedsolvem(const real_2d_array &a, const real_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const real_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, real_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Complex dense solver for A*X=B with N*N complex matrix A, N*M complex
matrices X and B. "Slow-but-feature-rich" version which provides
additional functions, at the cost of slower performance. Faster version
may be invoked with CMatrixSolveMFast() function.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* iterative refinement
* O(N^3+M*N^2) complexity
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system
! and performs iterative refinement, which results in
! significant performance penalty when compared with "fast"
! version which just performs LU decomposition and calls
! triangular solver.
!
! This performance penalty is especially visible in the
! multithreaded mode, because both condition number estimation
! and iterative refinement are inherently sequential
! calculations.
!
! Thus, if you need high performance and if you are pretty sure
! that your system is well conditioned, we strongly recommend
! you to use faster solver, CMatrixSolveMFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
RFS - iterative refinement switch:
* True - refinement is used.
Less performance, more precision.
* False - refinement is not used.
More performance, less precision.
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N,M], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixsolvem(const complex_2d_array &a, const ae_int_t n, const complex_2d_array &b, const ae_int_t m, const bool rfs, ae_int_t &info, densesolverreport &rep, complex_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Complex dense solver for A*X=B with N*N complex matrix A, N*M complex
matrices X and B. "Fast-but-lightweight" version which provides just
triangular solver - and no additional functions like iterative refinement
or condition number estimation.
Algorithm features:
* O(N^3+M*N^2) complexity
* no additional time consuming functions
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS:
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
* -1 N<=0 was passed
* 1 task is solved
B - array[N,M]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 16.03.2015 by Bochkanov Sergey
*************************************************************************/
void cmatrixsolvemfast(const complex_2d_array &a, const ae_int_t n, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Complex dense solver for A*x=B with N*N complex matrix A and N*1 complex
vectors x and b. "Slow-but-feature-rich" version of the solver.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* iterative refinement
* O(N^3) complexity
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system
! and performs iterative refinement, which results in
! significant performance penalty when compared with "fast"
! version which just performs LU decomposition and calls
! triangular solver.
!
! This performance penalty is especially visible in the
! multithreaded mode, because both condition number estimation
! and iterative refinement are inherently sequential
! calculations.
!
! Thus, if you need high performance and if you are pretty sure
! that your system is well conditioned, we strongly recommend
! you to use faster solver, CMatrixSolveFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixsolve(const complex_2d_array &a, const ae_int_t n, const complex_1d_array &b, ae_int_t &info, densesolverreport &rep, complex_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Complex dense solver for A*x=B with N*N complex matrix A and N*1 complex
vectors x and b. "Fast-but-lightweight" version of the solver.
Algorithm features:
* O(N^3) complexity
* no additional time consuming features, just triangular solver
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS:
A - array[0..N-1,0..N-1], system matrix
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS:
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
* -1 N<=0 was passed
* 1 task is solved
B - array[N]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixsolvefast(const complex_2d_array &a, const ae_int_t n, const complex_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N complex A given by its LU decomposition,
and N*M matrices X and B (multiple right sides). "Slow-but-feature-rich"
version of the solver.
Algorithm features:
* automatic detection of degenerate cases
* O(M*N^2) complexity
* condition number estimation
No iterative refinement is provided because exact form of original matrix
is not known to subroutine. Use CMatrixSolve or CMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just calls triangular
! solver.
!
! This performance penalty is especially apparent when you use
! ALGLIB parallel capabilities (condition number estimation is
! inherently sequential). It also becomes significant for
! small-scale problems.
!
! In such cases we strongly recommend you to use faster solver,
! CMatrixLUSolveMFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
LUA - array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
P - array[0..N-1], pivots array, RMatrixLU result
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N,M], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixlusolvem(const complex_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, complex_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N complex A given by its LU decomposition,
and N*M matrices X and B (multiple right sides). "Fast-but-lightweight"
version of the solver.
Algorithm features:
* O(M*N^2) complexity
* no additional time-consuming features
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
LUA - array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
P - array[0..N-1], pivots array, RMatrixLU result
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
* -1 N<=0 was passed
* 1 task is solved
B - array[N,M]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixlusolvemfast(const complex_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Complex dense linear solver for A*x=b with complex N*N A given by its LU
decomposition and N*1 vectors x and b. This is "slow-but-robust" version
of the complex linear solver with additional features which add
significant performance overhead. Faster version is CMatrixLUSolveFast()
function.
Algorithm features:
* automatic detection of degenerate cases
* O(N^2) complexity
* condition number estimation
No iterative refinement is provided because exact form of original matrix
is not known to subroutine. Use CMatrixSolve or CMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in 10-15x performance penalty when compared
! with "fast" version which just calls triangular solver.
!
! This performance penalty is insignificant when compared with
! cost of large LU decomposition. However, if you call this
! function many times for the same left side, this overhead
! BECOMES significant. It also becomes significant for small-
! scale problems.
!
! In such cases we strongly recommend you to use faster solver,
! CMatrixLUSolveFast() function.
INPUT PARAMETERS
LUA - array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
P - array[0..N-1], pivots array, CMatrixLU result
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixlusolve(const complex_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const complex_1d_array &b, ae_int_t &info, densesolverreport &rep, complex_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Complex dense linear solver for A*x=b with N*N complex A given by its LU
decomposition and N*1 vectors x and b. This is fast lightweight version
of solver, which is significantly faster than CMatrixLUSolve(), but does
not provide additional information (like condition numbers).
Algorithm features:
* O(N^2) complexity
* no additional time-consuming features, just triangular solver
INPUT PARAMETERS
LUA - array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
P - array[0..N-1], pivots array, CMatrixLU result
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is exactly singular (ill conditioned matrices
are not recognized).
* -1 N<=0 was passed
* 1 task is solved
B - array[N]:
* info>0 => overwritten by solution
* info=-3 => filled by zeros
NOTE: unlike CMatrixLUSolve(), this function does NOT check for
near-degeneracy of input matrix. It checks for EXACT degeneracy,
because this check is easy to do. However, very badly conditioned
matrices may went unnoticed.
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixlusolvefast(const complex_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const complex_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver. Same as RMatrixMixedSolveM(), but for complex matrices.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* iterative refinement
* O(M*N^2) complexity
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
LUA - array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
P - array[0..N-1], pivots array, CMatrixLU result
N - size of A
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N,M], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixmixedsolvem(const complex_2d_array &a, const complex_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, complex_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver. Same as RMatrixMixedSolve(), but for complex matrices.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* iterative refinement
* O(N^2) complexity
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
LUA - array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
P - array[0..N-1], pivots array, CMatrixLU result
N - size of A
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or exactly singular.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void cmatrixmixedsolve(const complex_2d_array &a, const complex_2d_array &lua, const integer_1d_array &p, const ae_int_t n, const complex_1d_array &b, ae_int_t &info, densesolverreport &rep, complex_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N symmetric positive definite matrix A, and
N*M vectors X and B. It is "slow-but-feature-rich" version of the solver.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* O(N^3+M*N^2) complexity
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just performs Cholesky
! decomposition and calls triangular solver.
!
! This performance penalty is especially visible in the
! multithreaded mode, because both condition number estimation
! and iterative refinement are inherently sequential
! calculations.
!
! Thus, if you need high performance and if you are pretty sure
! that your system is well conditioned, we strongly recommend
! you to use faster solver, SPDMatrixSolveMFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or non-SPD.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N,M], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void spdmatrixsolvem(const real_2d_array &a, const ae_int_t n, const bool isupper, const real_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, real_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N symmetric positive definite matrix A, and
N*M vectors X and B. It is "fast-but-lightweight" version of the solver.
Algorithm features:
* O(N^3+M*N^2) complexity
* matrix is represented by its upper or lower triangle
* no additional time consuming features
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular
* -1 N<=0 was passed
* 1 task was solved
B - array[N,M], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 17.03.2015 by Bochkanov Sergey
*************************************************************************/
void spdmatrixsolvemfast(const real_2d_array &a, const ae_int_t n, const bool isupper, const real_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense linear solver for A*x=b with N*N real symmetric positive definite
matrix A, N*1 vectors x and b. "Slow-but-feature-rich" version of the
solver.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* O(N^3) complexity
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just performs Cholesky
! decomposition and calls triangular solver.
!
! This performance penalty is especially visible in the
! multithreaded mode, because both condition number estimation
! and iterative refinement are inherently sequential
! calculations.
!
! Thus, if you need high performance and if you are pretty sure
! that your system is well conditioned, we strongly recommend
! you to use faster solver, SPDMatrixSolveFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 matrix is very badly conditioned or non-SPD.
* -1 N<=0 was passed
* 1 task is solved (but matrix A may be ill-conditioned,
check R1/RInf parameters for condition numbers).
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void spdmatrixsolve(const real_2d_array &a, const ae_int_t n, const bool isupper, const real_1d_array &b, ae_int_t &info, densesolverreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense linear solver for A*x=b with N*N real symmetric positive definite
matrix A, N*1 vectors x and b. "Fast-but-lightweight" version of the
solver.
Algorithm features:
* O(N^3) complexity
* matrix is represented by its upper or lower triangle
* no additional time consuming features like condition number estimation
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or non-SPD
* -1 N<=0 was passed
* 1 task was solved
B - array[N], it contains:
* info>0 => solution
* info=-3 => filled by zeros
-- ALGLIB --
Copyright 17.03.2015 by Bochkanov Sergey
*************************************************************************/
void spdmatrixsolvefast(const real_2d_array &a, const ae_int_t n, const bool isupper, const real_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N symmetric positive definite matrix A given
by its Cholesky decomposition, and N*M vectors X and B. It is "slow-but-
feature-rich" version of the solver which estimates condition number of
the system.
Algorithm features:
* automatic detection of degenerate cases
* O(M*N^2) complexity
* condition number estimation
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just calls triangular
! solver. Amount of overhead introduced depends on M (the
! larger - the more efficient).
!
! This performance penalty is insignificant when compared with
! cost of large LU decomposition. However, if you call this
! function many times for the same left side, this overhead
! BECOMES significant. It also becomes significant for small-
! scale problems (N<50).
!
! In such cases we strongly recommend you to use faster solver,
! SPDMatrixCholeskySolveMFast() function.
INPUT PARAMETERS
CHA - array[0..N-1,0..N-1], Cholesky decomposition,
SPDMatrixCholesky result
N - size of CHA
IsUpper - what half of CHA is provided
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or badly conditioned
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task was solved
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N]:
* for info>0 contains solution
* for info=-3 filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void spdmatrixcholeskysolvem(const real_2d_array &cha, const ae_int_t n, const bool isupper, const real_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, real_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N symmetric positive definite matrix A given
by its Cholesky decomposition, and N*M vectors X and B. It is "fast-but-
lightweight" version of the solver which just solves linear system,
without any additional functions.
Algorithm features:
* O(M*N^2) complexity
* matrix is represented by its upper or lower triangle
* no additional functionality
INPUT PARAMETERS
CHA - array[N,N], Cholesky decomposition,
SPDMatrixCholesky result
N - size of CHA
IsUpper - what half of CHA is provided
B - array[N,M], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or badly conditioned
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task was solved
B - array[N]:
* for info>0 overwritten by solution
* for info=-3 filled by zeros
-- ALGLIB --
Copyright 18.03.2015 by Bochkanov Sergey
*************************************************************************/
void spdmatrixcholeskysolvemfast(const real_2d_array &cha, const ae_int_t n, const bool isupper, const real_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*x=b with N*N symmetric positive definite matrix A given
by its Cholesky decomposition, and N*1 real vectors x and b. This is "slow-
but-feature-rich" version of the solver which, in addition to the
solution, performs condition number estimation.
Algorithm features:
* automatic detection of degenerate cases
* O(N^2) complexity
* condition number estimation
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in 10-15x performance penalty when compared
! with "fast" version which just calls triangular solver.
!
! This performance penalty is insignificant when compared with
! cost of large LU decomposition. However, if you call this
! function many times for the same left side, this overhead
! BECOMES significant. It also becomes significant for small-
! scale problems (N<50).
!
! In such cases we strongly recommend you to use faster solver,
! SPDMatrixCholeskySolveFast() function.
INPUT PARAMETERS
CHA - array[N,N], Cholesky decomposition,
SPDMatrixCholesky result
N - size of A
IsUpper - what half of CHA is provided
B - array[N], right part
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or ill conditioned
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N]:
* for info>0 - solution
* for info=-3 - filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void spdmatrixcholeskysolve(const real_2d_array &cha, const ae_int_t n, const bool isupper, const real_1d_array &b, ae_int_t &info, densesolverreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*x=b with N*N symmetric positive definite matrix A given
by its Cholesky decomposition, and N*1 real vectors x and b. This is "fast-
but-lightweight" version of the solver.
Algorithm features:
* O(N^2) complexity
* matrix is represented by its upper or lower triangle
* no additional features
INPUT PARAMETERS
CHA - array[N,N], Cholesky decomposition,
SPDMatrixCholesky result
N - size of A
IsUpper - what half of CHA is provided
B - array[N], right part
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or ill conditioned
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved
B - array[N]:
* for info>0 - overwritten by solution
* for info=-3 - filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void spdmatrixcholeskysolvefast(const real_2d_array &cha, const ae_int_t n, const bool isupper, const real_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B, with N*N Hermitian positive definite matrix A and
N*M complex matrices X and B. "Slow-but-feature-rich" version of the
solver.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* O(N^3+M*N^2) complexity
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just calls triangular
! solver.
!
! This performance penalty is especially apparent when you use
! ALGLIB parallel capabilities (condition number estimation is
! inherently sequential). It also becomes significant for
! small-scale problems (N<100).
!
! In such cases we strongly recommend you to use faster solver,
! HPDMatrixSolveMFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - same as in RMatrixSolve.
Returns -3 for non-HPD matrices.
Rep - same as in RMatrixSolve
X - same as in RMatrixSolve
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixsolvem(const complex_2d_array &a, const ae_int_t n, const bool isupper, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, complex_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B, with N*N Hermitian positive definite matrix A and
N*M complex matrices X and B. "Fast-but-lightweight" version of the solver.
Algorithm features:
* O(N^3+M*N^2) complexity
* matrix is represented by its upper or lower triangle
* no additional time consuming features like condition number estimation
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1,0..M-1], right part
M - right part size
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or is not positive definite.
B is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved
B - array[0..N-1]:
* overwritten by solution
* zeros, if problem was not solved
-- ALGLIB --
Copyright 17.03.2015 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixsolvemfast(const complex_2d_array &a, const ae_int_t n, const bool isupper, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*x=b, with N*N Hermitian positive definite matrix A, and
N*1 complex vectors x and b. "Slow-but-feature-rich" version of the
solver.
Algorithm features:
* automatic detection of degenerate cases
* condition number estimation
* O(N^3) complexity
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just performs Cholesky
! decomposition and calls triangular solver.
!
! This performance penalty is especially visible in the
! multithreaded mode, because both condition number estimation
! and iterative refinement are inherently sequential
! calculations.
!
! Thus, if you need high performance and if you are pretty sure
! that your system is well conditioned, we strongly recommend
! you to use faster solver, HPDMatrixSolveFast() function.
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - same as in RMatrixSolve
Returns -3 for non-HPD matrices.
Rep - same as in RMatrixSolve
X - same as in RMatrixSolve
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixsolve(const complex_2d_array &a, const ae_int_t n, const bool isupper, const complex_1d_array &b, ae_int_t &info, densesolverreport &rep, complex_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*x=b, with N*N Hermitian positive definite matrix A, and
N*1 complex vectors x and b. "Fast-but-lightweight" version of the
solver without additional functions.
Algorithm features:
* O(N^3) complexity
* matrix is represented by its upper or lower triangle
* no additional time consuming functions
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..N-1,0..N-1], system matrix
N - size of A
IsUpper - what half of A is provided
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or not positive definite
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task was solved
B - array[0..N-1]:
* overwritten by solution
* zeros, if A is exactly singular (diagonal of its LU
decomposition has exact zeros).
-- ALGLIB --
Copyright 17.03.2015 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixsolvefast(const complex_2d_array &a, const ae_int_t n, const bool isupper, const complex_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N Hermitian positive definite matrix A given
by its Cholesky decomposition and N*M complex matrices X and B. This is
"slow-but-feature-rich" version of the solver which, in addition to the
solution, estimates condition number of the system.
Algorithm features:
* automatic detection of degenerate cases
* O(M*N^2) complexity
* condition number estimation
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in significant performance penalty when
! compared with "fast" version which just calls triangular
! solver. Amount of overhead introduced depends on M (the
! larger - the more efficient).
!
! This performance penalty is insignificant when compared with
! cost of large Cholesky decomposition. However, if you call
! this function many times for the same left side, this
! overhead BECOMES significant. It also becomes significant
! for small-scale problems (N<50).
!
! In such cases we strongly recommend you to use faster solver,
! HPDMatrixCholeskySolveMFast() function.
INPUT PARAMETERS
CHA - array[N,N], Cholesky decomposition,
HPDMatrixCholesky result
N - size of CHA
IsUpper - what half of CHA is provided
B - array[N,M], right part
M - right part size
OUTPUT PARAMETERS:
Info - return code:
* -3 A is singular, or VERY close to singular.
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task was solved
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N]:
* for info>0 contains solution
* for info=-3 filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixcholeskysolvem(const complex_2d_array &cha, const ae_int_t n, const bool isupper, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, densesolverreport &rep, complex_2d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*X=B with N*N Hermitian positive definite matrix A given
by its Cholesky decomposition and N*M complex matrices X and B. This is
"fast-but-lightweight" version of the solver.
Algorithm features:
* O(M*N^2) complexity
* matrix is represented by its upper or lower triangle
* no additional time-consuming features
INPUT PARAMETERS
CHA - array[N,N], Cholesky decomposition,
HPDMatrixCholesky result
N - size of CHA
IsUpper - what half of CHA is provided
B - array[N,M], right part
M - right part size
OUTPUT PARAMETERS:
Info - return code:
* -3 A is singular, or VERY close to singular.
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task was solved
B - array[N]:
* for info>0 overwritten by solution
* for info=-3 filled by zeros
-- ALGLIB --
Copyright 18.03.2015 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixcholeskysolvemfast(const complex_2d_array &cha, const ae_int_t n, const bool isupper, const complex_2d_array &b, const ae_int_t m, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*x=b with N*N Hermitian positive definite matrix A given
by its Cholesky decomposition, and N*1 complex vectors x and b. This is
"slow-but-feature-rich" version of the solver which estimates condition
number of the system.
Algorithm features:
* automatic detection of degenerate cases
* O(N^2) complexity
* condition number estimation
* matrix is represented by its upper or lower triangle
No iterative refinement is provided because such partial representation of
matrix does not allow efficient calculation of extra-precise matrix-vector
products for large matrices. Use RMatrixSolve or RMatrixMixedSolve if you
need iterative refinement.
IMPORTANT: ! this function is NOT the most efficient linear solver provided
! by ALGLIB. It estimates condition number of linear system,
! which results in 10-15x performance penalty when compared
! with "fast" version which just calls triangular solver.
!
! This performance penalty is insignificant when compared with
! cost of large LU decomposition. However, if you call this
! function many times for the same left side, this overhead
! BECOMES significant. It also becomes significant for small-
! scale problems (N<50).
!
! In such cases we strongly recommend you to use faster solver,
! HPDMatrixCholeskySolveFast() function.
INPUT PARAMETERS
CHA - array[0..N-1,0..N-1], Cholesky decomposition,
SPDMatrixCholesky result
N - size of A
IsUpper - what half of CHA is provided
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or ill conditioned
X is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved
Rep - additional report, following fields are set:
* rep.r1 condition number in 1-norm
* rep.rinf condition number in inf-norm
X - array[N]:
* for info>0 - solution
* for info=-3 - filled by zeros
-- ALGLIB --
Copyright 27.01.2010 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixcholeskysolve(const complex_2d_array &cha, const ae_int_t n, const bool isupper, const complex_1d_array &b, ae_int_t &info, densesolverreport &rep, complex_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver for A*x=b with N*N Hermitian positive definite matrix A given
by its Cholesky decomposition, and N*1 complex vectors x and b. This is
"fast-but-lightweight" version of the solver.
Algorithm features:
* O(N^2) complexity
* matrix is represented by its upper or lower triangle
* no additional time-consuming features
INPUT PARAMETERS
CHA - array[0..N-1,0..N-1], Cholesky decomposition,
SPDMatrixCholesky result
N - size of A
IsUpper - what half of CHA is provided
B - array[0..N-1], right part
OUTPUT PARAMETERS
Info - return code:
* -3 A is is exactly singular or ill conditioned
B is filled by zeros in such cases.
* -1 N<=0 was passed
* 1 task is solved
B - array[N]:
* for info>0 - overwritten by solution
* for info=-3 - filled by zeros
-- ALGLIB --
Copyright 18.03.2015 by Bochkanov Sergey
*************************************************************************/
void hpdmatrixcholeskysolvefast(const complex_2d_array &cha, const ae_int_t n, const bool isupper, const complex_1d_array &b, ae_int_t &info, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Dense solver.
This subroutine finds solution of the linear system A*X=B with non-square,
possibly degenerate A. System is solved in the least squares sense, and
general least squares solution X = X0 + CX*y which minimizes |A*X-B| is
returned. If A is non-degenerate, solution in the usual sense is returned.
Algorithm features:
* automatic detection (and correct handling!) of degenerate cases
* iterative refinement
* O(N^3) complexity
! COMMERCIAL EDITION OF ALGLIB:
!
! Commercial Edition of ALGLIB includes following important improvements
! of this function:
! * high-performance native backend with same C# interface (C# version)
! * multithreading support (C++ and C# versions)
! * hardware vendor (Intel) implementations of linear algebra primitives
! (C++ and C# versions, x86/x64 platform)
!
! We recommend you to read 'Working with commercial version' section of
! ALGLIB Reference Manual in order to find out how to use performance-
! related features provided by commercial edition of ALGLIB.
INPUT PARAMETERS
A - array[0..NRows-1,0..NCols-1], system matrix
NRows - vertical size of A
NCols - horizontal size of A
B - array[0..NCols-1], right part
Threshold- a number in [0,1]. Singular values beyond Threshold are
considered zero. Set it to 0.0, if you don't understand
what it means, so the solver will choose good value on its
own.
OUTPUT PARAMETERS
Info - return code:
* -4 SVD subroutine failed
* -1 if NRows<=0 or NCols<=0 or Threshold<0 was passed
* 1 if task is solved
Rep - solver report, see below for more info
X - array[0..N-1,0..M-1], it contains:
* solution of A*X=B (even for singular A)
* zeros, if SVD subroutine failed
SOLVER REPORT
Subroutine sets following fields of the Rep structure:
* R2 reciprocal of condition number: 1/cond(A), 2-norm.
* N = NCols
* K dim(Null(A))
* CX array[0..N-1,0..K-1], kernel of A.
Columns of CX store such vectors that A*CX[i]=0.
-- ALGLIB --
Copyright 24.08.2009 by Bochkanov Sergey
*************************************************************************/
void rmatrixsolvels(const real_2d_array &a, const ae_int_t nrows, const ae_int_t ncols, const real_1d_array &b, const double threshold, ae_int_t &info, densesolverlsreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
#endif
#if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
This function initializes linear LSQR Solver. This solver is used to solve
non-symmetric (and, possibly, non-square) problems. Least squares solution
is returned for non-compatible systems.
USAGE:
1. User initializes algorithm state with LinLSQRCreate() call
2. User tunes solver parameters with LinLSQRSetCond() and other functions
3. User calls LinLSQRSolveSparse() function which takes algorithm state
and SparseMatrix object.
4. User calls LinLSQRResults() to get solution
5. Optionally, user may call LinLSQRSolveSparse() again to solve another
problem with different matrix and/or right part without reinitializing
LinLSQRState structure.
INPUT PARAMETERS:
M - number of rows in A
N - number of variables, N>0
OUTPUT PARAMETERS:
State - structure which stores algorithm state
NOTE: see also linlsqrcreatebuf() for version which reuses previously
allocated place as much as possible.
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
void linlsqrcreate(const ae_int_t m, const ae_int_t n, linlsqrstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function initializes linear LSQR Solver. It provides exactly same
functionality as linlsqrcreate(), but reuses previously allocated space
as much as possible.
INPUT PARAMETERS:
M - number of rows in A
N - number of variables, N>0
OUTPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 14.11.2018 by Bochkanov Sergey
*************************************************************************/
void linlsqrcreatebuf(const ae_int_t m, const ae_int_t n, const linlsqrstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function changes preconditioning settings of LinLSQQSolveSparse()
function. By default, SolveSparse() uses diagonal preconditioner, but if
you want to use solver without preconditioning, you can call this function
which forces solver to use unit matrix for preconditioning.
INPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 19.11.2012 by Bochkanov Sergey
*************************************************************************/
void linlsqrsetprecunit(const linlsqrstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function changes preconditioning settings of LinCGSolveSparse()
function. LinCGSolveSparse() will use diagonal of the system matrix as
preconditioner. This preconditioning mode is active by default.
INPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 19.11.2012 by Bochkanov Sergey
*************************************************************************/
void linlsqrsetprecdiag(const linlsqrstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets optional Tikhonov regularization coefficient.
It is zero by default.
INPUT PARAMETERS:
LambdaI - regularization factor, LambdaI>=0
OUTPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
void linlsqrsetlambdai(const linlsqrstate &state, const double lambdai, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Procedure for solution of A*x=b with sparse A.
INPUT PARAMETERS:
State - algorithm state
A - sparse M*N matrix in the CRS format (you MUST contvert it
to CRS format by calling SparseConvertToCRS() function
BEFORE you pass it to this function).
B - right part, array[M]
RESULT:
This function returns no result.
You can get solution by calling LinCGResults()
NOTE: this function uses lightweight preconditioning - multiplication by
inverse of diag(A). If you want, you can turn preconditioning off by
calling LinLSQRSetPrecUnit(). However, preconditioning cost is low
and preconditioner is very important for solution of badly scaled
problems.
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
void linlsqrsolvesparse(const linlsqrstate &state, const sparsematrix &a, const real_1d_array &b, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets stopping criteria.
INPUT PARAMETERS:
EpsA - algorithm will be stopped if ||A^T*Rk||/(||A||*||Rk||)<=EpsA.
EpsB - algorithm will be stopped if ||Rk||<=EpsB*||B||
MaxIts - algorithm will be stopped if number of iterations
more than MaxIts.
OUTPUT PARAMETERS:
State - structure which stores algorithm state
NOTE: if EpsA,EpsB,EpsC and MaxIts are zero then these variables will
be setted as default values.
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
void linlsqrsetcond(const linlsqrstate &state, const double epsa, const double epsb, const ae_int_t maxits, const xparams _xparams = alglib::xdefault);
/*************************************************************************
LSQR solver: results.
This function must be called after LinLSQRSolve
INPUT PARAMETERS:
State - algorithm state
OUTPUT PARAMETERS:
X - array[N], solution
Rep - optimization report:
* Rep.TerminationType completetion code:
* 1 ||Rk||<=EpsB*||B||
* 4 ||A^T*Rk||/(||A||*||Rk||)<=EpsA
* 5 MaxIts steps was taken
* 7 rounding errors prevent further progress,
X contains best point found so far.
(sometimes returned on singular systems)
* 8 user requested termination via calling
linlsqrrequesttermination()
* Rep.IterationsCount contains iterations count
* NMV countains number of matrix-vector calculations
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
void linlsqrresults(const linlsqrstate &state, real_1d_array &x, linlsqrreport &rep, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function turns on/off reporting.
INPUT PARAMETERS:
State - structure which stores algorithm state
NeedXRep- whether iteration reports are needed or not
If NeedXRep is True, algorithm will call rep() callback function if it is
provided to MinCGOptimize().
-- ALGLIB --
Copyright 30.11.2011 by Bochkanov Sergey
*************************************************************************/
void linlsqrsetxrep(const linlsqrstate &state, const bool needxrep, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function is used to peek into LSQR solver and get current iteration
counter. You can safely "peek" into the solver from another thread.
INPUT PARAMETERS:
S - solver object
RESULT:
iteration counter, in [0,INF)
-- ALGLIB --
Copyright 21.05.2018 by Bochkanov Sergey
*************************************************************************/
ae_int_t linlsqrpeekiterationscount(const linlsqrstate &s, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This subroutine submits request for termination of the running solver. It
can be called from some other thread which wants LSQR solver to terminate
(obviously, the thread running LSQR solver can not request termination
because it is already busy working on LSQR).
As result, solver stops at point which was "current accepted" when
termination request was submitted and returns error code 8 (successful
termination). Such termination is a smooth process which properly
deallocates all temporaries.
INPUT PARAMETERS:
State - solver structure
NOTE: calling this function on solver which is NOT running will have no
effect.
NOTE: multiple calls to this function are possible. First call is counted,
subsequent calls are silently ignored.
NOTE: solver clears termination flag on its start, it means that if some
other thread will request termination too soon, its request will went
unnoticed.
-- ALGLIB --
Copyright 08.10.2014 by Bochkanov Sergey
*************************************************************************/
void linlsqrrequesttermination(const linlsqrstate &state, const xparams _xparams = alglib::xdefault);
#endif
#if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
Polynomial root finding.
This function returns all roots of the polynomial
P(x) = a0 + a1*x + a2*x^2 + ... + an*x^n
Both real and complex roots are returned (see below).
INPUT PARAMETERS:
A - array[N+1], polynomial coefficients:
* A[0] is constant term
* A[N] is a coefficient of X^N
N - polynomial degree
OUTPUT PARAMETERS:
X - array of complex roots:
* for isolated real root, X[I] is strictly real: IMAGE(X[I])=0
* complex roots are always returned in pairs - roots occupy
positions I and I+1, with:
* X[I+1]=Conj(X[I])
* IMAGE(X[I]) > 0
* IMAGE(X[I+1]) = -IMAGE(X[I]) < 0
* multiple real roots may have non-zero imaginary part due
to roundoff errors. There is no reliable way to distinguish
real root of multiplicity 2 from two complex roots in
the presence of roundoff errors.
Rep - report, additional information, following fields are set:
* Rep.MaxErr - max( |P(xi)| ) for i=0..N-1. This field
allows to quickly estimate "quality" of the roots being
returned.
NOTE: this function uses companion matrix method to find roots. In case
internal EVD solver fails do find eigenvalues, exception is
generated.
NOTE: roots are not "polished" and no matrix balancing is performed
for them.
-- ALGLIB --
Copyright 24.02.2014 by Bochkanov Sergey
*************************************************************************/
void polynomialsolve(const real_1d_array &a, const ae_int_t n, complex_1d_array &x, polynomialsolverreport &rep, const xparams _xparams = alglib::xdefault);
#endif
#if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
LEVENBERG-MARQUARDT-LIKE NONLINEAR SOLVER
DESCRIPTION:
This algorithm solves system of nonlinear equations
F[0](x[0], ..., x[n-1]) = 0
F[1](x[0], ..., x[n-1]) = 0
...
F[M-1](x[0], ..., x[n-1]) = 0
with M/N do not necessarily coincide. Algorithm converges quadratically
under following conditions:
* the solution set XS is nonempty
* for some xs in XS there exist such neighbourhood N(xs) that:
* vector function F(x) and its Jacobian J(x) are continuously
differentiable on N
* ||F(x)|| provides local error bound on N, i.e. there exists such
c1, that ||F(x)||>c1*distance(x,XS)
Note that these conditions are much more weaker than usual non-singularity
conditions. For example, algorithm will converge for any affine function
F (whether its Jacobian singular or not).
REQUIREMENTS:
Algorithm will request following information during its operation:
* function vector F[] and Jacobian matrix at given point X
* value of merit function f(x)=F[0]^2(x)+...+F[M-1]^2(x) at given point X
USAGE:
1. User initializes algorithm state with NLEQCreateLM() call
2. User tunes solver parameters with NLEQSetCond(), NLEQSetStpMax() and
other functions
3. User calls NLEQSolve() function which takes algorithm state and
pointers (delegates, etc.) to callback functions which calculate merit
function value and Jacobian.
4. User calls NLEQResults() to get solution
5. Optionally, user may call NLEQRestartFrom() to solve another problem
with same parameters (N/M) but another starting point and/or another
function vector. NLEQRestartFrom() allows to reuse already initialized
structure.
INPUT PARAMETERS:
N - space dimension, N>1:
* if provided, only leading N elements of X are used
* if not provided, determined automatically from size of X
M - system size
X - starting point
OUTPUT PARAMETERS:
State - structure which stores algorithm state
NOTES:
1. you may tune stopping conditions with NLEQSetCond() function
2. if target function contains exp() or other fast growing functions, and
optimization algorithm makes too large steps which leads to overflow,
use NLEQSetStpMax() function to bound algorithm's steps.
3. this algorithm is a slightly modified implementation of the method
described in 'Levenberg-Marquardt method for constrained nonlinear
equations with strong local convergence properties' by Christian Kanzow
Nobuo Yamashita and Masao Fukushima and further developed in 'On the
convergence of a New Levenberg-Marquardt Method' by Jin-yan Fan and
Ya-Xiang Yuan.
-- ALGLIB --
Copyright 20.08.2009 by Bochkanov Sergey
*************************************************************************/
void nleqcreatelm(const ae_int_t n, const ae_int_t m, const real_1d_array &x, nleqstate &state, const xparams _xparams = alglib::xdefault);
void nleqcreatelm(const ae_int_t m, const real_1d_array &x, nleqstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets stopping conditions for the nonlinear solver
INPUT PARAMETERS:
State - structure which stores algorithm state
EpsF - >=0
The subroutine finishes its work if on k+1-th iteration
the condition ||F||<=EpsF is satisfied
MaxIts - maximum number of iterations. If MaxIts=0, the number of
iterations is unlimited.
Passing EpsF=0 and MaxIts=0 simultaneously will lead to automatic
stopping criterion selection (small EpsF).
NOTES:
-- ALGLIB --
Copyright 20.08.2010 by Bochkanov Sergey
*************************************************************************/
void nleqsetcond(const nleqstate &state, const double epsf, const ae_int_t maxits, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function turns on/off reporting.
INPUT PARAMETERS:
State - structure which stores algorithm state
NeedXRep- whether iteration reports are needed or not
If NeedXRep is True, algorithm will call rep() callback function if it is
provided to NLEQSolve().
-- ALGLIB --
Copyright 20.08.2010 by Bochkanov Sergey
*************************************************************************/
void nleqsetxrep(const nleqstate &state, const bool needxrep, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets maximum step length
INPUT PARAMETERS:
State - structure which stores algorithm state
StpMax - maximum step length, >=0. Set StpMax to 0.0, if you don't
want to limit step length.
Use this subroutine when target function contains exp() or other fast
growing functions, and algorithm makes too large steps which lead to
overflow. This function allows us to reject steps that are too large (and
therefore expose us to the possible overflow) without actually calculating
function value at the x+stp*d.
-- ALGLIB --
Copyright 20.08.2010 by Bochkanov Sergey
*************************************************************************/
void nleqsetstpmax(const nleqstate &state, const double stpmax, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function provides reverse communication interface
Reverse communication interface is not documented or recommended to use.
See below for functions which provide better documented API
*************************************************************************/
bool nleqiteration(const nleqstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This family of functions is used to launcn iterations of nonlinear solver
These functions accept following parameters:
state - algorithm state
func - callback which calculates function (or merit function)
value func at given point x
jac - callback which calculates function vector fi[]
and Jacobian jac at given point x
rep - optional callback which is called after each iteration
can be NULL
ptr - optional pointer which is passed to func/grad/hess/jac/rep
can be NULL
-- ALGLIB --
Copyright 20.03.2009 by Bochkanov Sergey
*************************************************************************/
void nleqsolve(nleqstate &state,
void (*func)(const real_1d_array &x, double &func, void *ptr),
void (*jac)(const real_1d_array &x, real_1d_array &fi, real_2d_array &jac, void *ptr),
void (*rep)(const real_1d_array &x, double func, void *ptr) = NULL,
void *ptr = NULL,
const xparams _xparams = alglib::xdefault);
/*************************************************************************
NLEQ solver results
INPUT PARAMETERS:
State - algorithm state.
OUTPUT PARAMETERS:
X - array[0..N-1], solution
Rep - optimization report:
* Rep.TerminationType completetion code:
* -4 ERROR: algorithm has converged to the
stationary point Xf which is local minimum of
f=F[0]^2+...+F[m-1]^2, but is not solution of
nonlinear system.
* 1 sqrt(f)<=EpsF.
* 5 MaxIts steps was taken
* 7 stopping conditions are too stringent,
further improvement is impossible
* Rep.IterationsCount contains iterations count
* NFEV countains number of function calculations
* ActiveConstraints contains number of active constraints
-- ALGLIB --
Copyright 20.08.2009 by Bochkanov Sergey
*************************************************************************/
void nleqresults(const nleqstate &state, real_1d_array &x, nleqreport &rep, const xparams _xparams = alglib::xdefault);
/*************************************************************************
NLEQ solver results
Buffered implementation of NLEQResults(), which uses pre-allocated buffer
to store X[]. If buffer size is too small, it resizes buffer. It is
intended to be used in the inner cycles of performance critical algorithms
where array reallocation penalty is too large to be ignored.
-- ALGLIB --
Copyright 20.08.2009 by Bochkanov Sergey
*************************************************************************/
void nleqresultsbuf(const nleqstate &state, real_1d_array &x, nleqreport &rep, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This subroutine restarts CG algorithm from new point. All optimization
parameters are left unchanged.
This function allows to solve multiple optimization problems (which
must have same number of dimensions) without object reallocation penalty.
INPUT PARAMETERS:
State - structure used for reverse communication previously
allocated with MinCGCreate call.
X - new starting point.
BndL - new lower bounds
BndU - new upper bounds
-- ALGLIB --
Copyright 30.07.2010 by Bochkanov Sergey
*************************************************************************/
void nleqrestartfrom(const nleqstate &state, const real_1d_array &x, const xparams _xparams = alglib::xdefault);
#endif
#if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
Sparse linear solver for A*x=b with N*N sparse real symmetric positive
definite matrix A, N*1 vectors x and b.
This solver converts input matrix to SKS format, performs Cholesky
factorization using SKS Cholesky subroutine (works well for limited
bandwidth matrices) and uses sparse triangular solvers to get solution of
the original system.
INPUT PARAMETERS
A - sparse matrix, must be NxN exactly
N - size of A, N>0
IsUpper - which half of A is provided (another half is ignored)
B - array[0..N-1], right part
OUTPUT PARAMETERS
Rep - solver report, following fields are set:
* rep.terminationtype - solver status; >0 for success,
set to -3 on failure (degenerate or non-SPD system).
X - array[N], it contains:
* rep.terminationtype>0 => solution
* rep.terminationtype=-3 => filled by zeros
-- ALGLIB --
Copyright 26.12.2017 by Bochkanov Sergey
*************************************************************************/
void sparsesolvesks(const sparsematrix &a, const ae_int_t n, const bool isupper, const real_1d_array &b, sparsesolverreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Sparse linear solver for A*x=b with N*N real symmetric positive definite
matrix A given by its Cholesky decomposition, and N*1 vectors x and b.
IMPORTANT: this solver requires input matrix to be in the SKS (Skyline)
sparse storage format. An exception will be generated if you
pass matrix in some other format (HASH or CRS).
INPUT PARAMETERS
A - sparse NxN matrix stored in SKS format, must be NxN exactly
N - size of A, N>0
IsUpper - which half of A is provided (another half is ignored)
B - array[N], right part
OUTPUT PARAMETERS
Rep - solver report, following fields are set:
* rep.terminationtype - solver status; >0 for success,
set to -3 on failure (degenerate or non-SPD system).
X - array[N], it contains:
* rep.terminationtype>0 => solution
* rep.terminationtype=-3 => filled by zeros
-- ALGLIB --
Copyright 26.12.2017 by Bochkanov Sergey
*************************************************************************/
void sparsecholeskysolvesks(const sparsematrix &a, const ae_int_t n, const bool isupper, const real_1d_array &b, sparsesolverreport &rep, real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Sparse linear solver for A*x=b with general (nonsymmetric) N*N sparse real
matrix A, N*1 vectors x and b.
This solver converts input matrix to CRS format, performs LU factorization
and uses sparse triangular solvers to get solution of the original system.
INPUT PARAMETERS
A - sparse matrix, must be NxN exactly, any storage format
N - size of A, N>0
B - array[0..N-1], right part
OUTPUT PARAMETERS
X - array[N], it contains:
* rep.terminationtype>0 => solution
* rep.terminationtype=-3 => filled by zeros
Rep - solver report, following fields are set:
* rep.terminationtype - solver status; >0 for success,
set to -3 on failure (degenerate system).
-- ALGLIB --
Copyright 26.12.2017 by Bochkanov Sergey
*************************************************************************/
void sparsesolve(const sparsematrix &a, const ae_int_t n, const real_1d_array &b, real_1d_array &x, sparsesolverreport &rep, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Sparse linear solver for A*x=b with general (nonsymmetric) N*N sparse real
matrix A given by its LU factorization, N*1 vectors x and b.
IMPORTANT: this solver requires input matrix to be in the CRS sparse
storage format. An exception will be generated if you pass
matrix in some other format (HASH or SKS).
INPUT PARAMETERS
A - LU factorization of the sparse matrix, must be NxN exactly
in CRS storage format
P, Q - pivot indexes from LU factorization
N - size of A, N>0
B - array[0..N-1], right part
OUTPUT PARAMETERS
X - array[N], it contains:
* rep.terminationtype>0 => solution
* rep.terminationtype=-3 => filled by zeros
Rep - solver report, following fields are set:
* rep.terminationtype - solver status; >0 for success,
set to -3 on failure (degenerate system).
-- ALGLIB --
Copyright 26.12.2017 by Bochkanov Sergey
*************************************************************************/
void sparselusolve(const sparsematrix &a, const integer_1d_array &p, const integer_1d_array &q, const ae_int_t n, const real_1d_array &b, real_1d_array &x, sparsesolverreport &rep, const xparams _xparams = alglib::xdefault);
#endif
#if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
/*************************************************************************
This function initializes linear CG Solver. This solver is used to solve
symmetric positive definite problems. If you want to solve nonsymmetric
(or non-positive definite) problem you may use LinLSQR solver provided by
ALGLIB.
USAGE:
1. User initializes algorithm state with LinCGCreate() call
2. User tunes solver parameters with LinCGSetCond() and other functions
3. Optionally, user sets starting point with LinCGSetStartingPoint()
4. User calls LinCGSolveSparse() function which takes algorithm state and
SparseMatrix object.
5. User calls LinCGResults() to get solution
6. Optionally, user may call LinCGSolveSparse() again to solve another
problem with different matrix and/or right part without reinitializing
LinCGState structure.
INPUT PARAMETERS:
N - problem dimension, N>0
OUTPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgcreate(const ae_int_t n, lincgstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets starting point.
By default, zero starting point is used.
INPUT PARAMETERS:
X - starting point, array[N]
OUTPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgsetstartingpoint(const lincgstate &state, const real_1d_array &x, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function changes preconditioning settings of LinCGSolveSparse()
function. By default, SolveSparse() uses diagonal preconditioner, but if
you want to use solver without preconditioning, you can call this function
which forces solver to use unit matrix for preconditioning.
INPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 19.11.2012 by Bochkanov Sergey
*************************************************************************/
void lincgsetprecunit(const lincgstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function changes preconditioning settings of LinCGSolveSparse()
function. LinCGSolveSparse() will use diagonal of the system matrix as
preconditioner. This preconditioning mode is active by default.
INPUT PARAMETERS:
State - structure which stores algorithm state
-- ALGLIB --
Copyright 19.11.2012 by Bochkanov Sergey
*************************************************************************/
void lincgsetprecdiag(const lincgstate &state, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets stopping criteria.
INPUT PARAMETERS:
EpsF - algorithm will be stopped if norm of residual is less than
EpsF*||b||.
MaxIts - algorithm will be stopped if number of iterations is more
than MaxIts.
OUTPUT PARAMETERS:
State - structure which stores algorithm state
NOTES:
If both EpsF and MaxIts are zero then small EpsF will be set to small
value.
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgsetcond(const lincgstate &state, const double epsf, const ae_int_t maxits, const xparams _xparams = alglib::xdefault);
/*************************************************************************
Procedure for solution of A*x=b with sparse A.
INPUT PARAMETERS:
State - algorithm state
A - sparse matrix in the CRS format (you MUST contvert it to
CRS format by calling SparseConvertToCRS() function).
IsUpper - whether upper or lower triangle of A is used:
* IsUpper=True => only upper triangle is used and lower
triangle is not referenced at all
* IsUpper=False => only lower triangle is used and upper
triangle is not referenced at all
B - right part, array[N]
RESULT:
This function returns no result.
You can get solution by calling LinCGResults()
NOTE: this function uses lightweight preconditioning - multiplication by
inverse of diag(A). If you want, you can turn preconditioning off by
calling LinCGSetPrecUnit(). However, preconditioning cost is low and
preconditioner is very important for solution of badly scaled
problems.
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgsolvesparse(const lincgstate &state, const sparsematrix &a, const bool isupper, const real_1d_array &b, const xparams _xparams = alglib::xdefault);
/*************************************************************************
CG-solver: results.
This function must be called after LinCGSolve
INPUT PARAMETERS:
State - algorithm state
OUTPUT PARAMETERS:
X - array[N], solution
Rep - optimization report:
* Rep.TerminationType completetion code:
* -5 input matrix is either not positive definite,
too large or too small
* -4 overflow/underflow during solution
(ill conditioned problem)
* 1 ||residual||<=EpsF*||b||
* 5 MaxIts steps was taken
* 7 rounding errors prevent further progress,
best point found is returned
* Rep.IterationsCount contains iterations count
* NMV countains number of matrix-vector calculations
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgresults(const lincgstate &state, real_1d_array &x, lincgreport &rep, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets restart frequency. By default, algorithm is restarted
after N subsequent iterations.
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgsetrestartfreq(const lincgstate &state, const ae_int_t srf, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function sets frequency of residual recalculations.
Algorithm updates residual r_k using iterative formula, but recalculates
it from scratch after each 10 iterations. It is done to avoid accumulation
of numerical errors and to stop algorithm when r_k starts to grow.
Such low update frequence (1/10) gives very little overhead, but makes
algorithm a bit more robust against numerical errors. However, you may
change it
INPUT PARAMETERS:
Freq - desired update frequency, Freq>=0.
Zero value means that no updates will be done.
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgsetrupdatefreq(const lincgstate &state, const ae_int_t freq, const xparams _xparams = alglib::xdefault);
/*************************************************************************
This function turns on/off reporting.
INPUT PARAMETERS:
State - structure which stores algorithm state
NeedXRep- whether iteration reports are needed or not
If NeedXRep is True, algorithm will call rep() callback function if it is
provided to MinCGOptimize().
-- ALGLIB --
Copyright 14.11.2011 by Bochkanov Sergey
*************************************************************************/
void lincgsetxrep(const lincgstate &state, const bool needxrep, const xparams _xparams = alglib::xdefault);
#endif
}
/////////////////////////////////////////////////////////////////////////
//
// THIS SECTION CONTAINS COMPUTATIONAL CORE DECLARATIONS (FUNCTIONS)
//
/////////////////////////////////////////////////////////////////////////
namespace alglib_impl
{
#if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
void rmatrixsolve(/* Real */ ae_matrix* a,
ae_int_t n,
/* Real */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void rmatrixsolvefast(/* Real */ ae_matrix* a,
ae_int_t n,
/* Real */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void rmatrixsolvem(/* Real */ ae_matrix* a,
ae_int_t n,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_bool rfs,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_matrix* x,
ae_state *_state);
void rmatrixsolvemfast(/* Real */ ae_matrix* a,
ae_int_t n,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void rmatrixlusolve(/* Real */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Real */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void rmatrixlusolvefast(/* Real */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Real */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void rmatrixlusolvem(/* Real */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_matrix* x,
ae_state *_state);
void rmatrixlusolvemfast(/* Real */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void rmatrixmixedsolve(/* Real */ ae_matrix* a,
/* Real */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Real */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void rmatrixmixedsolvem(/* Real */ ae_matrix* a,
/* Real */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_matrix* x,
ae_state *_state);
void cmatrixsolvem(/* Complex */ ae_matrix* a,
ae_int_t n,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_bool rfs,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_matrix* x,
ae_state *_state);
void cmatrixsolvemfast(/* Complex */ ae_matrix* a,
ae_int_t n,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void cmatrixsolve(/* Complex */ ae_matrix* a,
ae_int_t n,
/* Complex */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_vector* x,
ae_state *_state);
void cmatrixsolvefast(/* Complex */ ae_matrix* a,
ae_int_t n,
/* Complex */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void cmatrixlusolvem(/* Complex */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_matrix* x,
ae_state *_state);
void cmatrixlusolvemfast(/* Complex */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void cmatrixlusolve(/* Complex */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Complex */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_vector* x,
ae_state *_state);
void cmatrixlusolvefast(/* Complex */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Complex */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void cmatrixmixedsolvem(/* Complex */ ae_matrix* a,
/* Complex */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_matrix* x,
ae_state *_state);
void cmatrixmixedsolve(/* Complex */ ae_matrix* a,
/* Complex */ ae_matrix* lua,
/* Integer */ ae_vector* p,
ae_int_t n,
/* Complex */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_vector* x,
ae_state *_state);
void spdmatrixsolvem(/* Real */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_matrix* x,
ae_state *_state);
void spdmatrixsolvemfast(/* Real */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void spdmatrixsolve(/* Real */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void spdmatrixsolvefast(/* Real */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void spdmatrixcholeskysolvem(/* Real */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_matrix* x,
ae_state *_state);
void spdmatrixcholeskysolvemfast(/* Real */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void spdmatrixcholeskysolve(/* Real */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void spdmatrixcholeskysolvefast(/* Real */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void hpdmatrixsolvem(/* Complex */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_matrix* x,
ae_state *_state);
void hpdmatrixsolvemfast(/* Complex */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void hpdmatrixsolve(/* Complex */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_vector* x,
ae_state *_state);
void hpdmatrixsolvefast(/* Complex */ ae_matrix* a,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void hpdmatrixcholeskysolvem(/* Complex */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_matrix* x,
ae_state *_state);
void hpdmatrixcholeskysolvemfast(/* Complex */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_matrix* b,
ae_int_t m,
ae_int_t* info,
ae_state *_state);
void hpdmatrixcholeskysolve(/* Complex */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_vector* b,
ae_int_t* info,
densesolverreport* rep,
/* Complex */ ae_vector* x,
ae_state *_state);
void hpdmatrixcholeskysolvefast(/* Complex */ ae_matrix* cha,
ae_int_t n,
ae_bool isupper,
/* Complex */ ae_vector* b,
ae_int_t* info,
ae_state *_state);
void rmatrixsolvels(/* Real */ ae_matrix* a,
ae_int_t nrows,
ae_int_t ncols,
/* Real */ ae_vector* b,
double threshold,
ae_int_t* info,
densesolverlsreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void _densesolverreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _densesolverreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _densesolverreport_clear(void* _p);
void _densesolverreport_destroy(void* _p);
void _densesolverlsreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _densesolverlsreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _densesolverlsreport_clear(void* _p);
void _densesolverlsreport_destroy(void* _p);
#endif
#if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
void linlsqrcreate(ae_int_t m,
ae_int_t n,
linlsqrstate* state,
ae_state *_state);
void linlsqrcreatebuf(ae_int_t m,
ae_int_t n,
linlsqrstate* state,
ae_state *_state);
void linlsqrsetb(linlsqrstate* state,
/* Real */ ae_vector* b,
ae_state *_state);
void linlsqrsetprecunit(linlsqrstate* state, ae_state *_state);
void linlsqrsetprecdiag(linlsqrstate* state, ae_state *_state);
void linlsqrsetlambdai(linlsqrstate* state,
double lambdai,
ae_state *_state);
ae_bool linlsqriteration(linlsqrstate* state, ae_state *_state);
void linlsqrsolvesparse(linlsqrstate* state,
sparsematrix* a,
/* Real */ ae_vector* b,
ae_state *_state);
void linlsqrsetcond(linlsqrstate* state,
double epsa,
double epsb,
ae_int_t maxits,
ae_state *_state);
void linlsqrresults(linlsqrstate* state,
/* Real */ ae_vector* x,
linlsqrreport* rep,
ae_state *_state);
void linlsqrsetxrep(linlsqrstate* state,
ae_bool needxrep,
ae_state *_state);
void linlsqrrestart(linlsqrstate* state, ae_state *_state);
ae_int_t linlsqrpeekiterationscount(linlsqrstate* s, ae_state *_state);
void linlsqrrequesttermination(linlsqrstate* state, ae_state *_state);
void _linlsqrstate_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _linlsqrstate_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _linlsqrstate_clear(void* _p);
void _linlsqrstate_destroy(void* _p);
void _linlsqrreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _linlsqrreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _linlsqrreport_clear(void* _p);
void _linlsqrreport_destroy(void* _p);
#endif
#if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
void polynomialsolve(/* Real */ ae_vector* a,
ae_int_t n,
/* Complex */ ae_vector* x,
polynomialsolverreport* rep,
ae_state *_state);
void _polynomialsolverreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _polynomialsolverreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _polynomialsolverreport_clear(void* _p);
void _polynomialsolverreport_destroy(void* _p);
#endif
#if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
void nleqcreatelm(ae_int_t n,
ae_int_t m,
/* Real */ ae_vector* x,
nleqstate* state,
ae_state *_state);
void nleqsetcond(nleqstate* state,
double epsf,
ae_int_t maxits,
ae_state *_state);
void nleqsetxrep(nleqstate* state, ae_bool needxrep, ae_state *_state);
void nleqsetstpmax(nleqstate* state, double stpmax, ae_state *_state);
ae_bool nleqiteration(nleqstate* state, ae_state *_state);
void nleqresults(nleqstate* state,
/* Real */ ae_vector* x,
nleqreport* rep,
ae_state *_state);
void nleqresultsbuf(nleqstate* state,
/* Real */ ae_vector* x,
nleqreport* rep,
ae_state *_state);
void nleqrestartfrom(nleqstate* state,
/* Real */ ae_vector* x,
ae_state *_state);
void _nleqstate_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _nleqstate_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _nleqstate_clear(void* _p);
void _nleqstate_destroy(void* _p);
void _nleqreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _nleqreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _nleqreport_clear(void* _p);
void _nleqreport_destroy(void* _p);
#endif
#if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
void sparsesolvesks(sparsematrix* a,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_vector* b,
sparsesolverreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void sparsecholeskysolvesks(sparsematrix* a,
ae_int_t n,
ae_bool isupper,
/* Real */ ae_vector* b,
sparsesolverreport* rep,
/* Real */ ae_vector* x,
ae_state *_state);
void sparsesolve(sparsematrix* a,
ae_int_t n,
/* Real */ ae_vector* b,
/* Real */ ae_vector* x,
sparsesolverreport* rep,
ae_state *_state);
void sparselusolve(sparsematrix* a,
/* Integer */ ae_vector* p,
/* Integer */ ae_vector* q,
ae_int_t n,
/* Real */ ae_vector* b,
/* Real */ ae_vector* x,
sparsesolverreport* rep,
ae_state *_state);
void _sparsesolverreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _sparsesolverreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _sparsesolverreport_clear(void* _p);
void _sparsesolverreport_destroy(void* _p);
#endif
#if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
void lincgcreate(ae_int_t n, lincgstate* state, ae_state *_state);
void lincgsetstartingpoint(lincgstate* state,
/* Real */ ae_vector* x,
ae_state *_state);
void lincgsetb(lincgstate* state,
/* Real */ ae_vector* b,
ae_state *_state);
void lincgsetprecunit(lincgstate* state, ae_state *_state);
void lincgsetprecdiag(lincgstate* state, ae_state *_state);
void lincgsetcond(lincgstate* state,
double epsf,
ae_int_t maxits,
ae_state *_state);
ae_bool lincgiteration(lincgstate* state, ae_state *_state);
void lincgsolvesparse(lincgstate* state,
sparsematrix* a,
ae_bool isupper,
/* Real */ ae_vector* b,
ae_state *_state);
void lincgresults(lincgstate* state,
/* Real */ ae_vector* x,
lincgreport* rep,
ae_state *_state);
void lincgsetrestartfreq(lincgstate* state,
ae_int_t srf,
ae_state *_state);
void lincgsetrupdatefreq(lincgstate* state,
ae_int_t freq,
ae_state *_state);
void lincgsetxrep(lincgstate* state, ae_bool needxrep, ae_state *_state);
void lincgrestart(lincgstate* state, ae_state *_state);
void _lincgstate_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _lincgstate_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _lincgstate_clear(void* _p);
void _lincgstate_destroy(void* _p);
void _lincgreport_init(void* _p, ae_state *_state, ae_bool make_automatic);
void _lincgreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic);
void _lincgreport_clear(void* _p);
void _lincgreport_destroy(void* _p);
#endif
}
#endif