LCOV - code coverage report
Current view: top level - synthesis/MeasurementEquations/lbfgs - solvers.cc (source / functions) Hit Total Coverage
Test: casacpp_coverage.info Lines: 0 4130 0.0 %
Date: 2024-10-10 19:51:30 Functions: 0 329 0.0 %

          Line data    Source code
       1             : /*************************************************************************
       2             : ALGLIB 3.17.0 (source code generated 2020-12-27)
       3             : Copyright (c) Sergey Bochkanov (ALGLIB project).
       4             : 
       5             : >>> SOURCE LICENSE >>>
       6             : This program is free software; you can redistribute it and/or modify
       7             : it under the terms of the GNU General Public License as published by
       8             : the Free Software Foundation (www.fsf.org); either version 2 of the 
       9             : License, or (at your option) any later version.
      10             : 
      11             : This program is distributed in the hope that it will be useful,
      12             : but WITHOUT ANY WARRANTY; without even the implied warranty of
      13             : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
      14             : GNU General Public License for more details.
      15             : 
      16             : A copy of the GNU General Public License is available at
      17             : http://www.fsf.org/licensing/licenses
      18             : >>> END OF LICENSE >>>
      19             : *************************************************************************/
      20             : #ifdef _MSC_VER
      21             : #define _CRT_SECURE_NO_WARNINGS
      22             : #endif
      23             : #include "stdafx.h"
      24             : #include "solvers.h"
      25             : 
      26             : // disable some irrelevant warnings
      27             : #if (AE_COMPILER==AE_MSVC) && !defined(AE_ALL_WARNINGS)
      28             : #pragma warning(disable:4100)
      29             : #pragma warning(disable:4127)
      30             : #pragma warning(disable:4611)
      31             : #pragma warning(disable:4702)
      32             : #pragma warning(disable:4996)
      33             : #endif
      34             : 
      35             : /////////////////////////////////////////////////////////////////////////
      36             : //
      37             : // THIS SECTION CONTAINS IMPLEMENTATION OF C++ INTERFACE
      38             : //
      39             : /////////////////////////////////////////////////////////////////////////
      40             : namespace alglib
      41             : {
      42             : 
      43             : #if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
      44             : 
      45             : #endif
      46             : 
      47             : #if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
      48             : 
      49             : #endif
      50             : 
      51             : #if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
      52             : 
      53             : #endif
      54             : 
      55             : #if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
      56             : 
      57             : #endif
      58             : 
      59             : #if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
      60             : 
      61             : #endif
      62             : 
      63             : #if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
      64             : 
      65             : #endif
      66             : 
      67             : #if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
      68             : /*************************************************************************
      69             : 
      70             : *************************************************************************/
      71           0 : _densesolverreport_owner::_densesolverreport_owner()
      72             : {
      73             :     jmp_buf _break_jump;
      74             :     alglib_impl::ae_state _state;
      75             :     
      76           0 :     alglib_impl::ae_state_init(&_state);
      77           0 :     if( setjmp(_break_jump) )
      78             :     {
      79           0 :         if( p_struct!=NULL )
      80             :         {
      81           0 :             alglib_impl::_densesolverreport_destroy(p_struct);
      82           0 :             alglib_impl::ae_free(p_struct);
      83             :         }
      84           0 :         p_struct = NULL;
      85             : #if !defined(AE_NO_EXCEPTIONS)
      86           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
      87             : #else
      88             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
      89             :         return;
      90             : #endif
      91             :     }
      92           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
      93           0 :     p_struct = NULL;
      94           0 :     p_struct = (alglib_impl::densesolverreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::densesolverreport), &_state);
      95           0 :     memset(p_struct, 0, sizeof(alglib_impl::densesolverreport));
      96           0 :     alglib_impl::_densesolverreport_init(p_struct, &_state, ae_false);
      97           0 :     ae_state_clear(&_state);
      98           0 : }
      99             : 
     100           0 : _densesolverreport_owner::_densesolverreport_owner(const _densesolverreport_owner &rhs)
     101             : {
     102             :     jmp_buf _break_jump;
     103             :     alglib_impl::ae_state _state;
     104             :     
     105           0 :     alglib_impl::ae_state_init(&_state);
     106           0 :     if( setjmp(_break_jump) )
     107             :     {
     108           0 :         if( p_struct!=NULL )
     109             :         {
     110           0 :             alglib_impl::_densesolverreport_destroy(p_struct);
     111           0 :             alglib_impl::ae_free(p_struct);
     112             :         }
     113           0 :         p_struct = NULL;
     114             : #if !defined(AE_NO_EXCEPTIONS)
     115           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
     116             : #else
     117             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
     118             :         return;
     119             : #endif
     120             :     }
     121           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
     122           0 :     p_struct = NULL;
     123           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: densesolverreport copy constructor failure (source is not initialized)", &_state);
     124           0 :     p_struct = (alglib_impl::densesolverreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::densesolverreport), &_state);
     125           0 :     memset(p_struct, 0, sizeof(alglib_impl::densesolverreport));
     126           0 :     alglib_impl::_densesolverreport_init_copy(p_struct, const_cast<alglib_impl::densesolverreport*>(rhs.p_struct), &_state, ae_false);
     127           0 :     ae_state_clear(&_state);
     128           0 : }
     129             : 
     130           0 : _densesolverreport_owner& _densesolverreport_owner::operator=(const _densesolverreport_owner &rhs)
     131             : {
     132           0 :     if( this==&rhs )
     133           0 :         return *this;
     134             :     jmp_buf _break_jump;
     135             :     alglib_impl::ae_state _state;
     136             :     
     137           0 :     alglib_impl::ae_state_init(&_state);
     138           0 :     if( setjmp(_break_jump) )
     139             :     {
     140             : #if !defined(AE_NO_EXCEPTIONS)
     141           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
     142             : #else
     143             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
     144             :         return *this;
     145             : #endif
     146             :     }
     147           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
     148           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: densesolverreport assignment constructor failure (destination is not initialized)", &_state);
     149           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: densesolverreport assignment constructor failure (source is not initialized)", &_state);
     150           0 :     alglib_impl::_densesolverreport_destroy(p_struct);
     151           0 :     memset(p_struct, 0, sizeof(alglib_impl::densesolverreport));
     152           0 :     alglib_impl::_densesolverreport_init_copy(p_struct, const_cast<alglib_impl::densesolverreport*>(rhs.p_struct), &_state, ae_false);
     153           0 :     ae_state_clear(&_state);
     154           0 :     return *this;
     155             : }
     156             : 
     157           0 : _densesolverreport_owner::~_densesolverreport_owner()
     158             : {
     159           0 :     if( p_struct!=NULL )
     160             :     {
     161           0 :         alglib_impl::_densesolverreport_destroy(p_struct);
     162           0 :         ae_free(p_struct);
     163             :     }
     164           0 : }
     165             : 
     166           0 : alglib_impl::densesolverreport* _densesolverreport_owner::c_ptr()
     167             : {
     168           0 :     return p_struct;
     169             : }
     170             : 
     171           0 : alglib_impl::densesolverreport* _densesolverreport_owner::c_ptr() const
     172             : {
     173           0 :     return const_cast<alglib_impl::densesolverreport*>(p_struct);
     174             : }
     175           0 : densesolverreport::densesolverreport() : _densesolverreport_owner() ,r1(p_struct->r1),rinf(p_struct->rinf)
     176             : {
     177           0 : }
     178             : 
     179           0 : densesolverreport::densesolverreport(const densesolverreport &rhs):_densesolverreport_owner(rhs) ,r1(p_struct->r1),rinf(p_struct->rinf)
     180             : {
     181           0 : }
     182             : 
     183           0 : densesolverreport& densesolverreport::operator=(const densesolverreport &rhs)
     184             : {
     185           0 :     if( this==&rhs )
     186           0 :         return *this;
     187           0 :     _densesolverreport_owner::operator=(rhs);
     188           0 :     return *this;
     189             : }
     190             : 
     191           0 : densesolverreport::~densesolverreport()
     192             : {
     193           0 : }
     194             : 
     195             : 
     196             : /*************************************************************************
     197             : 
     198             : *************************************************************************/
     199           0 : _densesolverlsreport_owner::_densesolverlsreport_owner()
     200             : {
     201             :     jmp_buf _break_jump;
     202             :     alglib_impl::ae_state _state;
     203             :     
     204           0 :     alglib_impl::ae_state_init(&_state);
     205           0 :     if( setjmp(_break_jump) )
     206             :     {
     207           0 :         if( p_struct!=NULL )
     208             :         {
     209           0 :             alglib_impl::_densesolverlsreport_destroy(p_struct);
     210           0 :             alglib_impl::ae_free(p_struct);
     211             :         }
     212           0 :         p_struct = NULL;
     213             : #if !defined(AE_NO_EXCEPTIONS)
     214           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
     215             : #else
     216             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
     217             :         return;
     218             : #endif
     219             :     }
     220           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
     221           0 :     p_struct = NULL;
     222           0 :     p_struct = (alglib_impl::densesolverlsreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::densesolverlsreport), &_state);
     223           0 :     memset(p_struct, 0, sizeof(alglib_impl::densesolverlsreport));
     224           0 :     alglib_impl::_densesolverlsreport_init(p_struct, &_state, ae_false);
     225           0 :     ae_state_clear(&_state);
     226           0 : }
     227             : 
     228           0 : _densesolverlsreport_owner::_densesolverlsreport_owner(const _densesolverlsreport_owner &rhs)
     229             : {
     230             :     jmp_buf _break_jump;
     231             :     alglib_impl::ae_state _state;
     232             :     
     233           0 :     alglib_impl::ae_state_init(&_state);
     234           0 :     if( setjmp(_break_jump) )
     235             :     {
     236           0 :         if( p_struct!=NULL )
     237             :         {
     238           0 :             alglib_impl::_densesolverlsreport_destroy(p_struct);
     239           0 :             alglib_impl::ae_free(p_struct);
     240             :         }
     241           0 :         p_struct = NULL;
     242             : #if !defined(AE_NO_EXCEPTIONS)
     243           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
     244             : #else
     245             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
     246             :         return;
     247             : #endif
     248             :     }
     249           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
     250           0 :     p_struct = NULL;
     251           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: densesolverlsreport copy constructor failure (source is not initialized)", &_state);
     252           0 :     p_struct = (alglib_impl::densesolverlsreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::densesolverlsreport), &_state);
     253           0 :     memset(p_struct, 0, sizeof(alglib_impl::densesolverlsreport));
     254           0 :     alglib_impl::_densesolverlsreport_init_copy(p_struct, const_cast<alglib_impl::densesolverlsreport*>(rhs.p_struct), &_state, ae_false);
     255           0 :     ae_state_clear(&_state);
     256           0 : }
     257             : 
     258           0 : _densesolverlsreport_owner& _densesolverlsreport_owner::operator=(const _densesolverlsreport_owner &rhs)
     259             : {
     260           0 :     if( this==&rhs )
     261           0 :         return *this;
     262             :     jmp_buf _break_jump;
     263             :     alglib_impl::ae_state _state;
     264             :     
     265           0 :     alglib_impl::ae_state_init(&_state);
     266           0 :     if( setjmp(_break_jump) )
     267             :     {
     268             : #if !defined(AE_NO_EXCEPTIONS)
     269           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
     270             : #else
     271             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
     272             :         return *this;
     273             : #endif
     274             :     }
     275           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
     276           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: densesolverlsreport assignment constructor failure (destination is not initialized)", &_state);
     277           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: densesolverlsreport assignment constructor failure (source is not initialized)", &_state);
     278           0 :     alglib_impl::_densesolverlsreport_destroy(p_struct);
     279           0 :     memset(p_struct, 0, sizeof(alglib_impl::densesolverlsreport));
     280           0 :     alglib_impl::_densesolverlsreport_init_copy(p_struct, const_cast<alglib_impl::densesolverlsreport*>(rhs.p_struct), &_state, ae_false);
     281           0 :     ae_state_clear(&_state);
     282           0 :     return *this;
     283             : }
     284             : 
     285           0 : _densesolverlsreport_owner::~_densesolverlsreport_owner()
     286             : {
     287           0 :     if( p_struct!=NULL )
     288             :     {
     289           0 :         alglib_impl::_densesolverlsreport_destroy(p_struct);
     290           0 :         ae_free(p_struct);
     291             :     }
     292           0 : }
     293             : 
     294           0 : alglib_impl::densesolverlsreport* _densesolverlsreport_owner::c_ptr()
     295             : {
     296           0 :     return p_struct;
     297             : }
     298             : 
     299           0 : alglib_impl::densesolverlsreport* _densesolverlsreport_owner::c_ptr() const
     300             : {
     301           0 :     return const_cast<alglib_impl::densesolverlsreport*>(p_struct);
     302             : }
     303           0 : densesolverlsreport::densesolverlsreport() : _densesolverlsreport_owner() ,r2(p_struct->r2),cx(&p_struct->cx),n(p_struct->n),k(p_struct->k)
     304             : {
     305           0 : }
     306             : 
     307           0 : densesolverlsreport::densesolverlsreport(const densesolverlsreport &rhs):_densesolverlsreport_owner(rhs) ,r2(p_struct->r2),cx(&p_struct->cx),n(p_struct->n),k(p_struct->k)
     308             : {
     309           0 : }
     310             : 
     311           0 : densesolverlsreport& densesolverlsreport::operator=(const densesolverlsreport &rhs)
     312             : {
     313           0 :     if( this==&rhs )
     314           0 :         return *this;
     315           0 :     _densesolverlsreport_owner::operator=(rhs);
     316           0 :     return *this;
     317             : }
     318             : 
     319           0 : densesolverlsreport::~densesolverlsreport()
     320             : {
     321           0 : }
     322             : 
     323             : /*************************************************************************
     324             : Dense solver for A*x=b with N*N real matrix A and N*1 real vectorx  x  and
     325             : b. This is "slow-but-feature rich" version of the  linear  solver.  Faster
     326             : version is RMatrixSolveFast() function.
     327             : 
     328             : Algorithm features:
     329             : * automatic detection of degenerate cases
     330             : * condition number estimation
     331             : * iterative refinement
     332             : * O(N^3) complexity
     333             : 
     334             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
     335             :            ! by ALGLIB. It estimates condition  number  of  linear  system
     336             :            ! and  performs  iterative   refinement,   which   results   in
     337             :            ! significant performance penalty  when  compared  with  "fast"
     338             :            ! version  which  just  performs  LU  decomposition  and  calls
     339             :            ! triangular solver.
     340             :            !
     341             :            ! This  performance  penalty  is  especially  visible  in   the
     342             :            ! multithreaded mode, because both condition number  estimation
     343             :            ! and   iterative    refinement   are   inherently   sequential
     344             :            ! calculations. It is also very significant on small matrices.
     345             :            !
     346             :            ! Thus, if you need high performance and if you are pretty sure
     347             :            ! that your system is well conditioned, we  strongly  recommend
     348             :            ! you to use faster solver, RMatrixSolveFast() function.
     349             : 
     350             :   ! COMMERCIAL EDITION OF ALGLIB:
     351             :   !
     352             :   ! Commercial Edition of ALGLIB includes following important improvements
     353             :   ! of this function:
     354             :   ! * high-performance native backend with same C# interface (C# version)
     355             :   ! * multithreading support (C++ and C# versions)
     356             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
     357             :   !   (C++ and C# versions, x86/x64 platform)
     358             :   !
     359             :   ! We recommend you to read 'Working with commercial version' section  of
     360             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
     361             :   ! related features provided by commercial edition of ALGLIB.
     362             : 
     363             : INPUT PARAMETERS
     364             :     A       -   array[0..N-1,0..N-1], system matrix
     365             :     N       -   size of A
     366             :     B       -   array[0..N-1], right part
     367             : 
     368             : OUTPUT PARAMETERS
     369             :     Info    -   return code:
     370             :                 * -3    matrix is very badly conditioned or exactly singular.
     371             :                 * -1    N<=0 was passed
     372             :                 *  1    task is solved (but matrix A may be ill-conditioned,
     373             :                         check R1/RInf parameters for condition numbers).
     374             :     Rep     -   additional report, following fields are set:
     375             :                 * rep.r1    condition number in 1-norm
     376             :                 * rep.rinf  condition number in inf-norm
     377             :     X       -   array[N], it contains:
     378             :                 * info>0    =>  solution
     379             :                 * info=-3   =>  filled by zeros
     380             : 
     381             :   -- ALGLIB --
     382             :      Copyright 27.01.2010 by Bochkanov Sergey
     383             : *************************************************************************/
     384           0 : 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)
     385             : {
     386             :     jmp_buf _break_jump;
     387             :     alglib_impl::ae_state _alglib_env_state;
     388           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     389           0 :     if( setjmp(_break_jump) )
     390             :     {
     391             : #if !defined(AE_NO_EXCEPTIONS)
     392           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     393             : #else
     394             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     395             :         return;
     396             : #endif
     397             :     }
     398           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     399           0 :     if( _xparams.flags!=0x0 )
     400           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     401           0 :     alglib_impl::rmatrixsolve(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
     402           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     403           0 :     return;
     404             : }
     405             : 
     406             : /*************************************************************************
     407             : Dense solver.
     408             : 
     409             : This  subroutine  solves  a  system  A*x=b,  where A is NxN non-denegerate
     410             : real matrix, x  and  b  are  vectors.  This is a "fast" version of  linear
     411             : solver which does NOT provide  any  additional  functions  like  condition
     412             : number estimation or iterative refinement.
     413             : 
     414             : Algorithm features:
     415             : * efficient algorithm O(N^3) complexity
     416             : * no performance overhead from additional functionality
     417             : 
     418             : If you need condition number estimation or iterative refinement, use  more
     419             : feature-rich version - RMatrixSolve().
     420             : 
     421             :   ! COMMERCIAL EDITION OF ALGLIB:
     422             :   !
     423             :   ! Commercial Edition of ALGLIB includes following important improvements
     424             :   ! of this function:
     425             :   ! * high-performance native backend with same C# interface (C# version)
     426             :   ! * multithreading support (C++ and C# versions)
     427             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
     428             :   !   (C++ and C# versions, x86/x64 platform)
     429             :   !
     430             :   ! We recommend you to read 'Working with commercial version' section  of
     431             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
     432             :   ! related features provided by commercial edition of ALGLIB.
     433             : 
     434             : INPUT PARAMETERS
     435             :     A       -   array[0..N-1,0..N-1], system matrix
     436             :     N       -   size of A
     437             :     B       -   array[0..N-1], right part
     438             : 
     439             : OUTPUT PARAMETERS
     440             :     Info    -   return code:
     441             :                 * -3    matrix is exactly singular (ill conditioned matrices
     442             :                         are not recognized).
     443             :                 * -1    N<=0 was passed
     444             :                 *  1    task is solved
     445             :     B       -   array[N]:
     446             :                 * info>0    =>  overwritten by solution
     447             :                 * info=-3   =>  filled by zeros
     448             : 
     449             :   -- ALGLIB --
     450             :      Copyright 16.03.2015 by Bochkanov Sergey
     451             : *************************************************************************/
     452           0 : void rmatrixsolvefast(const real_2d_array &a, const ae_int_t n, const real_1d_array &b, ae_int_t &info, const xparams _xparams)
     453             : {
     454             :     jmp_buf _break_jump;
     455             :     alglib_impl::ae_state _alglib_env_state;
     456           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     457           0 :     if( setjmp(_break_jump) )
     458             :     {
     459             : #if !defined(AE_NO_EXCEPTIONS)
     460           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     461             : #else
     462             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     463             :         return;
     464             : #endif
     465             :     }
     466           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     467           0 :     if( _xparams.flags!=0x0 )
     468           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     469           0 :     alglib_impl::rmatrixsolvefast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
     470           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     471           0 :     return;
     472             : }
     473             : 
     474             : /*************************************************************************
     475             : Dense solver.
     476             : 
     477             : Similar to RMatrixSolve() but solves task with multiple right parts (where
     478             : b and x are NxM matrices). This is  "slow-but-robust"  version  of  linear
     479             : solver with additional functionality  like  condition  number  estimation.
     480             : There also exists faster version - RMatrixSolveMFast().
     481             : 
     482             : Algorithm features:
     483             : * automatic detection of degenerate cases
     484             : * condition number estimation
     485             : * optional iterative refinement
     486             : * O(N^3+M*N^2) complexity
     487             : 
     488             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
     489             :            ! by ALGLIB. It estimates condition  number  of  linear  system
     490             :            ! and  performs  iterative   refinement,   which   results   in
     491             :            ! significant performance penalty  when  compared  with  "fast"
     492             :            ! version  which  just  performs  LU  decomposition  and  calls
     493             :            ! triangular solver.
     494             :            !
     495             :            ! This  performance  penalty  is  especially  visible  in   the
     496             :            ! multithreaded mode, because both condition number  estimation
     497             :            ! and   iterative    refinement   are   inherently   sequential
     498             :            ! calculations. It also very significant on small matrices.
     499             :            !
     500             :            ! Thus, if you need high performance and if you are pretty sure
     501             :            ! that your system is well conditioned, we  strongly  recommend
     502             :            ! you to use faster solver, RMatrixSolveMFast() function.
     503             : 
     504             :   ! COMMERCIAL EDITION OF ALGLIB:
     505             :   !
     506             :   ! Commercial Edition of ALGLIB includes following important improvements
     507             :   ! of this function:
     508             :   ! * high-performance native backend with same C# interface (C# version)
     509             :   ! * multithreading support (C++ and C# versions)
     510             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
     511             :   !   (C++ and C# versions, x86/x64 platform)
     512             :   !
     513             :   ! We recommend you to read 'Working with commercial version' section  of
     514             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
     515             :   ! related features provided by commercial edition of ALGLIB.
     516             : 
     517             : INPUT PARAMETERS
     518             :     A       -   array[0..N-1,0..N-1], system matrix
     519             :     N       -   size of A
     520             :     B       -   array[0..N-1,0..M-1], right part
     521             :     M       -   right part size
     522             :     RFS     -   iterative refinement switch:
     523             :                 * True - refinement is used.
     524             :                   Less performance, more precision.
     525             :                 * False - refinement is not used.
     526             :                   More performance, less precision.
     527             : 
     528             : OUTPUT PARAMETERS
     529             :     Info    -   return code:
     530             :                 * -3    A is ill conditioned or singular.
     531             :                         X is filled by zeros in such cases.
     532             :                 * -1    N<=0 was passed
     533             :                 *  1    task is solved (but matrix A may be ill-conditioned,
     534             :                         check R1/RInf parameters for condition numbers).
     535             :     Rep     -   additional report, following fields are set:
     536             :                 * rep.r1    condition number in 1-norm
     537             :                 * rep.rinf  condition number in inf-norm
     538             :     X       -   array[N], it contains:
     539             :                 * info>0    =>  solution
     540             :                 * info=-3   =>  filled by zeros
     541             : 
     542             : 
     543             :   -- ALGLIB --
     544             :      Copyright 27.01.2010 by Bochkanov Sergey
     545             : *************************************************************************/
     546           0 : 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)
     547             : {
     548             :     jmp_buf _break_jump;
     549             :     alglib_impl::ae_state _alglib_env_state;
     550           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     551           0 :     if( setjmp(_break_jump) )
     552             :     {
     553             : #if !defined(AE_NO_EXCEPTIONS)
     554           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     555             : #else
     556             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     557             :         return;
     558             : #endif
     559             :     }
     560           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     561           0 :     if( _xparams.flags!=0x0 )
     562           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     563           0 :     alglib_impl::rmatrixsolvem(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, rfs, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
     564           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     565           0 :     return;
     566             : }
     567             : 
     568             : /*************************************************************************
     569             : Dense solver.
     570             : 
     571             : Similar to RMatrixSolve() but solves task with multiple right parts (where
     572             : b and x are NxM matrices). This is "fast" version of linear  solver  which
     573             : does NOT offer additional functions like condition  number  estimation  or
     574             : iterative refinement.
     575             : 
     576             : Algorithm features:
     577             : * O(N^3+M*N^2) complexity
     578             : * no additional functionality, highest performance
     579             : 
     580             :   ! COMMERCIAL EDITION OF ALGLIB:
     581             :   !
     582             :   ! Commercial Edition of ALGLIB includes following important improvements
     583             :   ! of this function:
     584             :   ! * high-performance native backend with same C# interface (C# version)
     585             :   ! * multithreading support (C++ and C# versions)
     586             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
     587             :   !   (C++ and C# versions, x86/x64 platform)
     588             :   !
     589             :   ! We recommend you to read 'Working with commercial version' section  of
     590             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
     591             :   ! related features provided by commercial edition of ALGLIB.
     592             : 
     593             : INPUT PARAMETERS
     594             :     A       -   array[0..N-1,0..N-1], system matrix
     595             :     N       -   size of A
     596             :     B       -   array[0..N-1,0..M-1], right part
     597             :     M       -   right part size
     598             :     RFS     -   iterative refinement switch:
     599             :                 * True - refinement is used.
     600             :                   Less performance, more precision.
     601             :                 * False - refinement is not used.
     602             :                   More performance, less precision.
     603             : 
     604             : OUTPUT PARAMETERS
     605             :     Info    -   return code:
     606             :                 * -3    matrix is exactly singular (ill conditioned matrices
     607             :                         are not recognized).
     608             :                         X is filled by zeros in such cases.
     609             :                 * -1    N<=0 was passed
     610             :                 *  1    task is solved
     611             :     Rep     -   additional report, following fields are set:
     612             :                 * rep.r1    condition number in 1-norm
     613             :                 * rep.rinf  condition number in inf-norm
     614             :     B       -   array[N]:
     615             :                 * info>0    =>  overwritten by solution
     616             :                 * info=-3   =>  filled by zeros
     617             : 
     618             : 
     619             :   -- ALGLIB --
     620             :      Copyright 27.01.2010 by Bochkanov Sergey
     621             : *************************************************************************/
     622           0 : 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)
     623             : {
     624             :     jmp_buf _break_jump;
     625             :     alglib_impl::ae_state _alglib_env_state;
     626           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     627           0 :     if( setjmp(_break_jump) )
     628             :     {
     629             : #if !defined(AE_NO_EXCEPTIONS)
     630           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     631             : #else
     632             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     633             :         return;
     634             : #endif
     635             :     }
     636           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     637           0 :     if( _xparams.flags!=0x0 )
     638           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     639           0 :     alglib_impl::rmatrixsolvemfast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
     640           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     641           0 :     return;
     642             : }
     643             : 
     644             : /*************************************************************************
     645             : Dense solver.
     646             : 
     647             : This  subroutine  solves  a  system  A*x=b,  where A is NxN non-denegerate
     648             : real matrix given by its LU decomposition, x and b are real vectors.  This
     649             : is "slow-but-robust" version of the linear LU-based solver. Faster version
     650             : is RMatrixLUSolveFast() function.
     651             : 
     652             : Algorithm features:
     653             : * automatic detection of degenerate cases
     654             : * O(N^2) complexity
     655             : * condition number estimation
     656             : 
     657             : No iterative refinement  is provided because exact form of original matrix
     658             : is not known to subroutine. Use RMatrixSolve or RMatrixMixedSolve  if  you
     659             : need iterative refinement.
     660             : 
     661             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
     662             :            ! by ALGLIB. It estimates condition  number  of  linear system,
     663             :            ! which results in 10-15x  performance  penalty  when  compared
     664             :            ! with "fast" version which just calls triangular solver.
     665             :            !
     666             :            ! This performance penalty is insignificant  when compared with
     667             :            ! cost of large LU decomposition.  However,  if you  call  this
     668             :            ! function many times for the same  left  side,  this  overhead
     669             :            ! BECOMES significant. It  also  becomes significant for small-
     670             :            ! scale problems.
     671             :            !
     672             :            ! In such cases we strongly recommend you to use faster solver,
     673             :            ! RMatrixLUSolveFast() function.
     674             : 
     675             : INPUT PARAMETERS
     676             :     LUA     -   array[N,N], LU decomposition, RMatrixLU result
     677             :     P       -   array[N], pivots array, RMatrixLU result
     678             :     N       -   size of A
     679             :     B       -   array[N], right part
     680             : 
     681             : OUTPUT PARAMETERS
     682             :     Info    -   return code:
     683             :                 * -3    matrix is very badly conditioned or exactly singular.
     684             :                 * -1    N<=0 was passed
     685             :                 *  1    task is solved (but matrix A may be ill-conditioned,
     686             :                         check R1/RInf parameters for condition numbers).
     687             :     Rep     -   additional report, following fields are set:
     688             :                 * rep.r1    condition number in 1-norm
     689             :                 * rep.rinf  condition number in inf-norm
     690             :     X       -   array[N], it contains:
     691             :                 * info>0    =>  solution
     692             :                 * info=-3   =>  filled by zeros
     693             : 
     694             : 
     695             :   -- ALGLIB --
     696             :      Copyright 27.01.2010 by Bochkanov Sergey
     697             : *************************************************************************/
     698           0 : 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)
     699             : {
     700             :     jmp_buf _break_jump;
     701             :     alglib_impl::ae_state _alglib_env_state;
     702           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     703           0 :     if( setjmp(_break_jump) )
     704             :     {
     705             : #if !defined(AE_NO_EXCEPTIONS)
     706           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     707             : #else
     708             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     709             :         return;
     710             : #endif
     711             :     }
     712           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     713           0 :     if( _xparams.flags!=0x0 )
     714           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     715           0 :     alglib_impl::rmatrixlusolve(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
     716           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     717           0 :     return;
     718             : }
     719             : 
     720             : /*************************************************************************
     721             : Dense solver.
     722             : 
     723             : This  subroutine  solves  a  system  A*x=b,  where A is NxN non-denegerate
     724             : real matrix given by its LU decomposition, x and b are real vectors.  This
     725             : is "fast-without-any-checks" version of the linear LU-based solver. Slower
     726             : but more robust version is RMatrixLUSolve() function.
     727             : 
     728             : Algorithm features:
     729             : * O(N^2) complexity
     730             : * fast algorithm without ANY additional checks, just triangular solver
     731             : 
     732             : INPUT PARAMETERS
     733             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
     734             :     P       -   array[0..N-1], pivots array, RMatrixLU result
     735             :     N       -   size of A
     736             :     B       -   array[0..N-1], right part
     737             : 
     738             : OUTPUT PARAMETERS
     739             :     Info    -   return code:
     740             :                 * -3    matrix is exactly singular (ill conditioned matrices
     741             :                         are not recognized).
     742             :                         X is filled by zeros in such cases.
     743             :                 * -1    N<=0 was passed
     744             :                 *  1    task is solved
     745             :     B       -   array[N]:
     746             :                 * info>0    =>  overwritten by solution
     747             :                 * info=-3   =>  filled by zeros
     748             : 
     749             :   -- ALGLIB --
     750             :      Copyright 18.03.2015 by Bochkanov Sergey
     751             : *************************************************************************/
     752           0 : 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)
     753             : {
     754             :     jmp_buf _break_jump;
     755             :     alglib_impl::ae_state _alglib_env_state;
     756           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     757           0 :     if( setjmp(_break_jump) )
     758             :     {
     759             : #if !defined(AE_NO_EXCEPTIONS)
     760           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     761             : #else
     762             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     763             :         return;
     764             : #endif
     765             :     }
     766           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     767           0 :     if( _xparams.flags!=0x0 )
     768           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     769           0 :     alglib_impl::rmatrixlusolvefast(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
     770           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     771           0 :     return;
     772             : }
     773             : 
     774             : /*************************************************************************
     775             : Dense solver.
     776             : 
     777             : Similar to RMatrixLUSolve() but solves  task  with  multiple  right  parts
     778             : (where b and x are NxM matrices). This  is  "robust-but-slow"  version  of
     779             : LU-based solver which performs additional  checks  for  non-degeneracy  of
     780             : inputs (condition number estimation). If you need  best  performance,  use
     781             : "fast-without-any-checks" version, RMatrixLUSolveMFast().
     782             : 
     783             : Algorithm features:
     784             : * automatic detection of degenerate cases
     785             : * O(M*N^2) complexity
     786             : * condition number estimation
     787             : 
     788             : No iterative refinement  is provided because exact form of original matrix
     789             : is not known to subroutine. Use RMatrixSolve or RMatrixMixedSolve  if  you
     790             : need iterative refinement.
     791             : 
     792             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
     793             :            ! by ALGLIB. It estimates condition  number  of  linear system,
     794             :            ! which  results  in  significant  performance   penalty   when
     795             :            ! compared with "fast"  version  which  just  calls  triangular
     796             :            ! solver.
     797             :            !
     798             :            ! This performance penalty is especially apparent when you  use
     799             :            ! ALGLIB parallel capabilities (condition number estimation  is
     800             :            ! inherently  sequential).  It   also   becomes significant for
     801             :            ! small-scale problems.
     802             :            !
     803             :            ! In such cases we strongly recommend you to use faster solver,
     804             :            ! RMatrixLUSolveMFast() function.
     805             : 
     806             :   ! COMMERCIAL EDITION OF ALGLIB:
     807             :   !
     808             :   ! Commercial Edition of ALGLIB includes following important improvements
     809             :   ! of this function:
     810             :   ! * high-performance native backend with same C# interface (C# version)
     811             :   ! * multithreading support (C++ and C# versions)
     812             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
     813             :   !   (C++ and C# versions, x86/x64 platform)
     814             :   !
     815             :   ! We recommend you to read 'Working with commercial version' section  of
     816             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
     817             :   ! related features provided by commercial edition of ALGLIB.
     818             : 
     819             : INPUT PARAMETERS
     820             :     LUA     -   array[N,N], LU decomposition, RMatrixLU result
     821             :     P       -   array[N], pivots array, RMatrixLU result
     822             :     N       -   size of A
     823             :     B       -   array[0..N-1,0..M-1], right part
     824             :     M       -   right part size
     825             : 
     826             : OUTPUT PARAMETERS
     827             :     Info    -   return code:
     828             :                 * -3    matrix is very badly conditioned or exactly singular.
     829             :                         X is filled by zeros in such cases.
     830             :                 * -1    N<=0 was passed
     831             :                 *  1    task is solved (but matrix A may be ill-conditioned,
     832             :                         check R1/RInf parameters for condition numbers).
     833             :     Rep     -   additional report, following fields are set:
     834             :                 * rep.r1    condition number in 1-norm
     835             :                 * rep.rinf  condition number in inf-norm
     836             :     X       -   array[N,M], it contains:
     837             :                 * info>0    =>  solution
     838             :                 * info=-3   =>  filled by zeros
     839             : 
     840             : 
     841             :   -- ALGLIB --
     842             :      Copyright 27.01.2010 by Bochkanov Sergey
     843             : *************************************************************************/
     844           0 : 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)
     845             : {
     846             :     jmp_buf _break_jump;
     847             :     alglib_impl::ae_state _alglib_env_state;
     848           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     849           0 :     if( setjmp(_break_jump) )
     850             :     {
     851             : #if !defined(AE_NO_EXCEPTIONS)
     852           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     853             : #else
     854             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     855             :         return;
     856             : #endif
     857             :     }
     858           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     859           0 :     if( _xparams.flags!=0x0 )
     860           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     861           0 :     alglib_impl::rmatrixlusolvem(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
     862           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     863           0 :     return;
     864             : }
     865             : 
     866             : /*************************************************************************
     867             : Dense solver.
     868             : 
     869             : Similar to RMatrixLUSolve() but solves  task  with  multiple  right parts,
     870             : where b and x are NxM matrices.  This is "fast-without-any-checks" version
     871             : of LU-based solver. It does not estimate  condition number  of  a  system,
     872             : so it is extremely fast. If you need better detection  of  near-degenerate
     873             : cases, use RMatrixLUSolveM() function.
     874             : 
     875             : Algorithm features:
     876             : * O(M*N^2) complexity
     877             : * fast algorithm without ANY additional checks, just triangular solver
     878             : 
     879             :   ! COMMERCIAL EDITION OF ALGLIB:
     880             :   !
     881             :   ! Commercial Edition of ALGLIB includes following important improvements
     882             :   ! of this function:
     883             :   ! * high-performance native backend with same C# interface (C# version)
     884             :   ! * multithreading support (C++ and C# versions)
     885             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
     886             :   !   (C++ and C# versions, x86/x64 platform)
     887             :   !
     888             :   ! We recommend you to read 'Working with commercial version' section  of
     889             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
     890             :   ! related features provided by commercial edition of ALGLIB.
     891             : 
     892             : INPUT PARAMETERS:
     893             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
     894             :     P       -   array[0..N-1], pivots array, RMatrixLU result
     895             :     N       -   size of A
     896             :     B       -   array[0..N-1,0..M-1], right part
     897             :     M       -   right part size
     898             : 
     899             : OUTPUT PARAMETERS:
     900             :     Info    -   return code:
     901             :                 * -3    matrix is exactly singular (ill conditioned matrices
     902             :                         are not recognized).
     903             :                 * -1    N<=0 was passed
     904             :                 *  1    task is solved
     905             :     B       -   array[N,M]:
     906             :                 * info>0    =>  overwritten by solution
     907             :                 * info=-3   =>  filled by zeros
     908             : 
     909             :   -- ALGLIB --
     910             :      Copyright 18.03.2015 by Bochkanov Sergey
     911             : *************************************************************************/
     912           0 : 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)
     913             : {
     914             :     jmp_buf _break_jump;
     915             :     alglib_impl::ae_state _alglib_env_state;
     916           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     917           0 :     if( setjmp(_break_jump) )
     918             :     {
     919             : #if !defined(AE_NO_EXCEPTIONS)
     920           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     921             : #else
     922             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     923             :         return;
     924             : #endif
     925             :     }
     926           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     927           0 :     if( _xparams.flags!=0x0 )
     928           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     929           0 :     alglib_impl::rmatrixlusolvemfast(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
     930           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     931           0 :     return;
     932             : }
     933             : 
     934             : /*************************************************************************
     935             : Dense solver.
     936             : 
     937             : This  subroutine  solves  a  system  A*x=b,  where BOTH ORIGINAL A AND ITS
     938             : LU DECOMPOSITION ARE KNOWN. You can use it if for some  reasons  you  have
     939             : both A and its LU decomposition.
     940             : 
     941             : Algorithm features:
     942             : * automatic detection of degenerate cases
     943             : * condition number estimation
     944             : * iterative refinement
     945             : * O(N^2) complexity
     946             : 
     947             : INPUT PARAMETERS
     948             :     A       -   array[0..N-1,0..N-1], system matrix
     949             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
     950             :     P       -   array[0..N-1], pivots array, RMatrixLU result
     951             :     N       -   size of A
     952             :     B       -   array[0..N-1], right part
     953             : 
     954             : OUTPUT PARAMETERS
     955             :     Info    -   return code:
     956             :                 * -3    matrix is very badly conditioned or exactly singular.
     957             :                 * -1    N<=0 was passed
     958             :                 *  1    task is solved (but matrix A may be ill-conditioned,
     959             :                         check R1/RInf parameters for condition numbers).
     960             :     Rep     -   additional report, following fields are set:
     961             :                 * rep.r1    condition number in 1-norm
     962             :                 * rep.rinf  condition number in inf-norm
     963             :     X       -   array[N], it contains:
     964             :                 * info>0    =>  solution
     965             :                 * info=-3   =>  filled by zeros
     966             : 
     967             :   -- ALGLIB --
     968             :      Copyright 27.01.2010 by Bochkanov Sergey
     969             : *************************************************************************/
     970           0 : 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)
     971             : {
     972             :     jmp_buf _break_jump;
     973             :     alglib_impl::ae_state _alglib_env_state;
     974           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
     975           0 :     if( setjmp(_break_jump) )
     976             :     {
     977             : #if !defined(AE_NO_EXCEPTIONS)
     978           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
     979             : #else
     980             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
     981             :         return;
     982             : #endif
     983             :     }
     984           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
     985           0 :     if( _xparams.flags!=0x0 )
     986           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
     987           0 :     alglib_impl::rmatrixmixedsolve(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
     988           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
     989           0 :     return;
     990             : }
     991             : 
     992             : /*************************************************************************
     993             : Dense solver.
     994             : 
     995             : Similar to RMatrixMixedSolve() but  solves task with multiple right  parts
     996             : (where b and x are NxM matrices).
     997             : 
     998             : Algorithm features:
     999             : * automatic detection of degenerate cases
    1000             : * condition number estimation
    1001             : * iterative refinement
    1002             : * O(M*N^2) complexity
    1003             : 
    1004             : INPUT PARAMETERS
    1005             :     A       -   array[0..N-1,0..N-1], system matrix
    1006             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    1007             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    1008             :     N       -   size of A
    1009             :     B       -   array[0..N-1,0..M-1], right part
    1010             :     M       -   right part size
    1011             : 
    1012             : OUTPUT PARAMETERS
    1013             :     Info    -   return code:
    1014             :                 * -3    matrix is very badly conditioned or exactly singular.
    1015             :                 * -1    N<=0 was passed
    1016             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1017             :                         check R1/RInf parameters for condition numbers).
    1018             :     Rep     -   additional report, following fields are set:
    1019             :                 * rep.r1    condition number in 1-norm
    1020             :                 * rep.rinf  condition number in inf-norm
    1021             :     X       -   array[N,M], it contains:
    1022             :                 * info>0    =>  solution
    1023             :                 * info=-3   =>  filled by zeros
    1024             : 
    1025             :   -- ALGLIB --
    1026             :      Copyright 27.01.2010 by Bochkanov Sergey
    1027             : *************************************************************************/
    1028           0 : 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)
    1029             : {
    1030             :     jmp_buf _break_jump;
    1031             :     alglib_impl::ae_state _alglib_env_state;
    1032           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1033           0 :     if( setjmp(_break_jump) )
    1034             :     {
    1035             : #if !defined(AE_NO_EXCEPTIONS)
    1036           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1037             : #else
    1038             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1039             :         return;
    1040             : #endif
    1041             :     }
    1042           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1043           0 :     if( _xparams.flags!=0x0 )
    1044           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1045           0 :     alglib_impl::rmatrixmixedsolvem(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    1046           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1047           0 :     return;
    1048             : }
    1049             : 
    1050             : /*************************************************************************
    1051             : Complex dense solver for A*X=B with N*N  complex  matrix  A,  N*M  complex
    1052             : matrices  X  and  B.  "Slow-but-feature-rich"   version   which   provides
    1053             : additional functions, at the cost of slower  performance.  Faster  version
    1054             : may be invoked with CMatrixSolveMFast() function.
    1055             : 
    1056             : Algorithm features:
    1057             : * automatic detection of degenerate cases
    1058             : * condition number estimation
    1059             : * iterative refinement
    1060             : * O(N^3+M*N^2) complexity
    1061             : 
    1062             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    1063             :            ! by ALGLIB. It estimates condition  number  of  linear  system
    1064             :            ! and  performs  iterative   refinement,   which   results   in
    1065             :            ! significant performance penalty  when  compared  with  "fast"
    1066             :            ! version  which  just  performs  LU  decomposition  and  calls
    1067             :            ! triangular solver.
    1068             :            !
    1069             :            ! This  performance  penalty  is  especially  visible  in   the
    1070             :            ! multithreaded mode, because both condition number  estimation
    1071             :            ! and   iterative    refinement   are   inherently   sequential
    1072             :            ! calculations.
    1073             :            !
    1074             :            ! Thus, if you need high performance and if you are pretty sure
    1075             :            ! that your system is well conditioned, we  strongly  recommend
    1076             :            ! you to use faster solver, CMatrixSolveMFast() function.
    1077             : 
    1078             :   ! COMMERCIAL EDITION OF ALGLIB:
    1079             :   !
    1080             :   ! Commercial Edition of ALGLIB includes following important improvements
    1081             :   ! of this function:
    1082             :   ! * high-performance native backend with same C# interface (C# version)
    1083             :   ! * multithreading support (C++ and C# versions)
    1084             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1085             :   !   (C++ and C# versions, x86/x64 platform)
    1086             :   !
    1087             :   ! We recommend you to read 'Working with commercial version' section  of
    1088             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1089             :   ! related features provided by commercial edition of ALGLIB.
    1090             : 
    1091             : INPUT PARAMETERS
    1092             :     A       -   array[0..N-1,0..N-1], system matrix
    1093             :     N       -   size of A
    1094             :     B       -   array[0..N-1,0..M-1], right part
    1095             :     M       -   right part size
    1096             :     RFS     -   iterative refinement switch:
    1097             :                 * True - refinement is used.
    1098             :                   Less performance, more precision.
    1099             :                 * False - refinement is not used.
    1100             :                   More performance, less precision.
    1101             : 
    1102             : OUTPUT PARAMETERS
    1103             :     Info    -   return code:
    1104             :                 * -3    matrix is very badly conditioned or exactly singular.
    1105             :                         X is filled by zeros in such cases.
    1106             :                 * -1    N<=0 was passed
    1107             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1108             :                         check R1/RInf parameters for condition numbers).
    1109             :     Rep     -   additional report, following fields are set:
    1110             :                 * rep.r1    condition number in 1-norm
    1111             :                 * rep.rinf  condition number in inf-norm
    1112             :     X       -   array[N,M], it contains:
    1113             :                 * info>0    =>  solution
    1114             :                 * info=-3   =>  filled by zeros
    1115             : 
    1116             :   -- ALGLIB --
    1117             :      Copyright 27.01.2010 by Bochkanov Sergey
    1118             : *************************************************************************/
    1119           0 : 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)
    1120             : {
    1121             :     jmp_buf _break_jump;
    1122             :     alglib_impl::ae_state _alglib_env_state;
    1123           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1124           0 :     if( setjmp(_break_jump) )
    1125             :     {
    1126             : #if !defined(AE_NO_EXCEPTIONS)
    1127           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1128             : #else
    1129             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1130             :         return;
    1131             : #endif
    1132             :     }
    1133           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1134           0 :     if( _xparams.flags!=0x0 )
    1135           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1136           0 :     alglib_impl::cmatrixsolvem(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, rfs, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    1137           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1138           0 :     return;
    1139             : }
    1140             : 
    1141             : /*************************************************************************
    1142             : Complex dense solver for A*X=B with N*N  complex  matrix  A,  N*M  complex
    1143             : matrices  X  and  B.  "Fast-but-lightweight" version which  provides  just
    1144             : triangular solver - and no additional functions like iterative  refinement
    1145             : or condition number estimation.
    1146             : 
    1147             : Algorithm features:
    1148             : * O(N^3+M*N^2) complexity
    1149             : * no additional time consuming functions
    1150             : 
    1151             :   ! COMMERCIAL EDITION OF ALGLIB:
    1152             :   !
    1153             :   ! Commercial Edition of ALGLIB includes following important improvements
    1154             :   ! of this function:
    1155             :   ! * high-performance native backend with same C# interface (C# version)
    1156             :   ! * multithreading support (C++ and C# versions)
    1157             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1158             :   !   (C++ and C# versions, x86/x64 platform)
    1159             :   !
    1160             :   ! We recommend you to read 'Working with commercial version' section  of
    1161             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1162             :   ! related features provided by commercial edition of ALGLIB.
    1163             : 
    1164             : INPUT PARAMETERS
    1165             :     A       -   array[0..N-1,0..N-1], system matrix
    1166             :     N       -   size of A
    1167             :     B       -   array[0..N-1,0..M-1], right part
    1168             :     M       -   right part size
    1169             : 
    1170             : OUTPUT PARAMETERS:
    1171             :     Info    -   return code:
    1172             :                 * -3    matrix is exactly singular (ill conditioned matrices
    1173             :                         are not recognized).
    1174             :                 * -1    N<=0 was passed
    1175             :                 *  1    task is solved
    1176             :     B       -   array[N,M]:
    1177             :                 * info>0    =>  overwritten by solution
    1178             :                 * info=-3   =>  filled by zeros
    1179             : 
    1180             :   -- ALGLIB --
    1181             :      Copyright 16.03.2015 by Bochkanov Sergey
    1182             : *************************************************************************/
    1183           0 : 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)
    1184             : {
    1185             :     jmp_buf _break_jump;
    1186             :     alglib_impl::ae_state _alglib_env_state;
    1187           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1188           0 :     if( setjmp(_break_jump) )
    1189             :     {
    1190             : #if !defined(AE_NO_EXCEPTIONS)
    1191           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1192             : #else
    1193             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1194             :         return;
    1195             : #endif
    1196             :     }
    1197           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1198           0 :     if( _xparams.flags!=0x0 )
    1199           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1200           0 :     alglib_impl::cmatrixsolvemfast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
    1201           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1202           0 :     return;
    1203             : }
    1204             : 
    1205             : /*************************************************************************
    1206             : Complex dense solver for A*x=B with N*N complex matrix A and  N*1  complex
    1207             : vectors x and b. "Slow-but-feature-rich" version of the solver.
    1208             : 
    1209             : Algorithm features:
    1210             : * automatic detection of degenerate cases
    1211             : * condition number estimation
    1212             : * iterative refinement
    1213             : * O(N^3) complexity
    1214             : 
    1215             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    1216             :            ! by ALGLIB. It estimates condition  number  of  linear  system
    1217             :            ! and  performs  iterative   refinement,   which   results   in
    1218             :            ! significant performance penalty  when  compared  with  "fast"
    1219             :            ! version  which  just  performs  LU  decomposition  and  calls
    1220             :            ! triangular solver.
    1221             :            !
    1222             :            ! This  performance  penalty  is  especially  visible  in   the
    1223             :            ! multithreaded mode, because both condition number  estimation
    1224             :            ! and   iterative    refinement   are   inherently   sequential
    1225             :            ! calculations.
    1226             :            !
    1227             :            ! Thus, if you need high performance and if you are pretty sure
    1228             :            ! that your system is well conditioned, we  strongly  recommend
    1229             :            ! you to use faster solver, CMatrixSolveFast() function.
    1230             : 
    1231             :   ! COMMERCIAL EDITION OF ALGLIB:
    1232             :   !
    1233             :   ! Commercial Edition of ALGLIB includes following important improvements
    1234             :   ! of this function:
    1235             :   ! * high-performance native backend with same C# interface (C# version)
    1236             :   ! * multithreading support (C++ and C# versions)
    1237             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1238             :   !   (C++ and C# versions, x86/x64 platform)
    1239             :   !
    1240             :   ! We recommend you to read 'Working with commercial version' section  of
    1241             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1242             :   ! related features provided by commercial edition of ALGLIB.
    1243             : 
    1244             : INPUT PARAMETERS
    1245             :     A       -   array[0..N-1,0..N-1], system matrix
    1246             :     N       -   size of A
    1247             :     B       -   array[0..N-1], right part
    1248             : 
    1249             : OUTPUT PARAMETERS
    1250             :     Info    -   return code:
    1251             :                 * -3    matrix is very badly conditioned or exactly singular.
    1252             :                 * -1    N<=0 was passed
    1253             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1254             :                         check R1/RInf parameters for condition numbers).
    1255             :     Rep     -   additional report, following fields are set:
    1256             :                 * rep.r1    condition number in 1-norm
    1257             :                 * rep.rinf  condition number in inf-norm
    1258             :     X       -   array[N], it contains:
    1259             :                 * info>0    =>  solution
    1260             :                 * info=-3   =>  filled by zeros
    1261             : 
    1262             :   -- ALGLIB --
    1263             :      Copyright 27.01.2010 by Bochkanov Sergey
    1264             : *************************************************************************/
    1265           0 : 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)
    1266             : {
    1267             :     jmp_buf _break_jump;
    1268             :     alglib_impl::ae_state _alglib_env_state;
    1269           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1270           0 :     if( setjmp(_break_jump) )
    1271             :     {
    1272             : #if !defined(AE_NO_EXCEPTIONS)
    1273           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1274             : #else
    1275             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1276             :         return;
    1277             : #endif
    1278             :     }
    1279           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1280           0 :     if( _xparams.flags!=0x0 )
    1281           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1282           0 :     alglib_impl::cmatrixsolve(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    1283           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1284           0 :     return;
    1285             : }
    1286             : 
    1287             : /*************************************************************************
    1288             : Complex dense solver for A*x=B with N*N complex matrix A and  N*1  complex
    1289             : vectors x and b. "Fast-but-lightweight" version of the solver.
    1290             : 
    1291             : Algorithm features:
    1292             : * O(N^3) complexity
    1293             : * no additional time consuming features, just triangular solver
    1294             : 
    1295             :   ! COMMERCIAL EDITION OF ALGLIB:
    1296             :   !
    1297             :   ! Commercial Edition of ALGLIB includes following important improvements
    1298             :   ! of this function:
    1299             :   ! * high-performance native backend with same C# interface (C# version)
    1300             :   ! * multithreading support (C++ and C# versions)
    1301             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1302             :   !   (C++ and C# versions, x86/x64 platform)
    1303             :   !
    1304             :   ! We recommend you to read 'Working with commercial version' section  of
    1305             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1306             :   ! related features provided by commercial edition of ALGLIB.
    1307             : 
    1308             : INPUT PARAMETERS:
    1309             :     A       -   array[0..N-1,0..N-1], system matrix
    1310             :     N       -   size of A
    1311             :     B       -   array[0..N-1], right part
    1312             : 
    1313             : OUTPUT PARAMETERS:
    1314             :     Info    -   return code:
    1315             :                 * -3    matrix is exactly singular (ill conditioned matrices
    1316             :                         are not recognized).
    1317             :                 * -1    N<=0 was passed
    1318             :                 *  1    task is solved
    1319             :     B       -   array[N]:
    1320             :                 * info>0    =>  overwritten by solution
    1321             :                 * info=-3   =>  filled by zeros
    1322             : 
    1323             :   -- ALGLIB --
    1324             :      Copyright 27.01.2010 by Bochkanov Sergey
    1325             : *************************************************************************/
    1326           0 : void cmatrixsolvefast(const complex_2d_array &a, const ae_int_t n, const complex_1d_array &b, ae_int_t &info, const xparams _xparams)
    1327             : {
    1328             :     jmp_buf _break_jump;
    1329             :     alglib_impl::ae_state _alglib_env_state;
    1330           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1331           0 :     if( setjmp(_break_jump) )
    1332             :     {
    1333             : #if !defined(AE_NO_EXCEPTIONS)
    1334           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1335             : #else
    1336             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1337             :         return;
    1338             : #endif
    1339             :     }
    1340           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1341           0 :     if( _xparams.flags!=0x0 )
    1342           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1343           0 :     alglib_impl::cmatrixsolvefast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
    1344           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1345           0 :     return;
    1346             : }
    1347             : 
    1348             : /*************************************************************************
    1349             : Dense solver for A*X=B with N*N complex A given by its  LU  decomposition,
    1350             : and N*M matrices X and B (multiple right sides).   "Slow-but-feature-rich"
    1351             : version of the solver.
    1352             : 
    1353             : Algorithm features:
    1354             : * automatic detection of degenerate cases
    1355             : * O(M*N^2) complexity
    1356             : * condition number estimation
    1357             : 
    1358             : No iterative refinement  is provided because exact form of original matrix
    1359             : is not known to subroutine. Use CMatrixSolve or CMatrixMixedSolve  if  you
    1360             : need iterative refinement.
    1361             : 
    1362             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    1363             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    1364             :            ! which  results  in  significant  performance   penalty   when
    1365             :            ! compared with "fast"  version  which  just  calls  triangular
    1366             :            ! solver.
    1367             :            !
    1368             :            ! This performance penalty is especially apparent when you  use
    1369             :            ! ALGLIB parallel capabilities (condition number estimation  is
    1370             :            ! inherently  sequential).  It   also   becomes significant for
    1371             :            ! small-scale problems.
    1372             :            !
    1373             :            ! In such cases we strongly recommend you to use faster solver,
    1374             :            ! CMatrixLUSolveMFast() function.
    1375             : 
    1376             :   ! COMMERCIAL EDITION OF ALGLIB:
    1377             :   !
    1378             :   ! Commercial Edition of ALGLIB includes following important improvements
    1379             :   ! of this function:
    1380             :   ! * high-performance native backend with same C# interface (C# version)
    1381             :   ! * multithreading support (C++ and C# versions)
    1382             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1383             :   !   (C++ and C# versions, x86/x64 platform)
    1384             :   !
    1385             :   ! We recommend you to read 'Working with commercial version' section  of
    1386             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1387             :   ! related features provided by commercial edition of ALGLIB.
    1388             : 
    1389             : INPUT PARAMETERS
    1390             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    1391             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    1392             :     N       -   size of A
    1393             :     B       -   array[0..N-1,0..M-1], right part
    1394             :     M       -   right part size
    1395             : 
    1396             : OUTPUT PARAMETERS
    1397             :     Info    -   return code:
    1398             :                 * -3    matrix is very badly conditioned or exactly singular.
    1399             :                 * -1    N<=0 was passed
    1400             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1401             :                         check R1/RInf parameters for condition numbers).
    1402             :     Rep     -   additional report, following fields are set:
    1403             :                 * rep.r1    condition number in 1-norm
    1404             :                 * rep.rinf  condition number in inf-norm
    1405             :     X       -   array[N,M], it contains:
    1406             :                 * info>0    =>  solution
    1407             :                 * info=-3   =>  filled by zeros
    1408             : 
    1409             :   -- ALGLIB --
    1410             :      Copyright 27.01.2010 by Bochkanov Sergey
    1411             : *************************************************************************/
    1412           0 : 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)
    1413             : {
    1414             :     jmp_buf _break_jump;
    1415             :     alglib_impl::ae_state _alglib_env_state;
    1416           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1417           0 :     if( setjmp(_break_jump) )
    1418             :     {
    1419             : #if !defined(AE_NO_EXCEPTIONS)
    1420           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1421             : #else
    1422             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1423             :         return;
    1424             : #endif
    1425             :     }
    1426           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1427           0 :     if( _xparams.flags!=0x0 )
    1428           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1429           0 :     alglib_impl::cmatrixlusolvem(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    1430           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1431           0 :     return;
    1432             : }
    1433             : 
    1434             : /*************************************************************************
    1435             : Dense solver for A*X=B with N*N complex A given by its  LU  decomposition,
    1436             : and N*M matrices X and B (multiple  right  sides).  "Fast-but-lightweight"
    1437             : version of the solver.
    1438             : 
    1439             : Algorithm features:
    1440             : * O(M*N^2) complexity
    1441             : * no additional time-consuming features
    1442             : 
    1443             :   ! COMMERCIAL EDITION OF ALGLIB:
    1444             :   !
    1445             :   ! Commercial Edition of ALGLIB includes following important improvements
    1446             :   ! of this function:
    1447             :   ! * high-performance native backend with same C# interface (C# version)
    1448             :   ! * multithreading support (C++ and C# versions)
    1449             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1450             :   !   (C++ and C# versions, x86/x64 platform)
    1451             :   !
    1452             :   ! We recommend you to read 'Working with commercial version' section  of
    1453             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1454             :   ! related features provided by commercial edition of ALGLIB.
    1455             : 
    1456             : INPUT PARAMETERS
    1457             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    1458             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    1459             :     N       -   size of A
    1460             :     B       -   array[0..N-1,0..M-1], right part
    1461             :     M       -   right part size
    1462             : 
    1463             : OUTPUT PARAMETERS
    1464             :     Info    -   return code:
    1465             :                 * -3    matrix is exactly singular (ill conditioned matrices
    1466             :                         are not recognized).
    1467             :                 * -1    N<=0 was passed
    1468             :                 *  1    task is solved
    1469             :     B       -   array[N,M]:
    1470             :                 * info>0    =>  overwritten by solution
    1471             :                 * info=-3   =>  filled by zeros
    1472             : 
    1473             : 
    1474             :   -- ALGLIB --
    1475             :      Copyright 27.01.2010 by Bochkanov Sergey
    1476             : *************************************************************************/
    1477           0 : 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)
    1478             : {
    1479             :     jmp_buf _break_jump;
    1480             :     alglib_impl::ae_state _alglib_env_state;
    1481           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1482           0 :     if( setjmp(_break_jump) )
    1483             :     {
    1484             : #if !defined(AE_NO_EXCEPTIONS)
    1485           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1486             : #else
    1487             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1488             :         return;
    1489             : #endif
    1490             :     }
    1491           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1492           0 :     if( _xparams.flags!=0x0 )
    1493           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1494           0 :     alglib_impl::cmatrixlusolvemfast(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
    1495           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1496           0 :     return;
    1497             : }
    1498             : 
    1499             : /*************************************************************************
    1500             : Complex dense linear solver for A*x=b with complex N*N A  given  by its LU
    1501             : decomposition and N*1 vectors x and b. This is  "slow-but-robust"  version
    1502             : of  the  complex  linear  solver  with  additional  features   which   add
    1503             : significant performance overhead. Faster version  is  CMatrixLUSolveFast()
    1504             : function.
    1505             : 
    1506             : Algorithm features:
    1507             : * automatic detection of degenerate cases
    1508             : * O(N^2) complexity
    1509             : * condition number estimation
    1510             : 
    1511             : No iterative refinement is provided because exact form of original matrix
    1512             : is not known to subroutine. Use CMatrixSolve or CMatrixMixedSolve  if  you
    1513             : need iterative refinement.
    1514             : 
    1515             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    1516             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    1517             :            ! which results in 10-15x  performance  penalty  when  compared
    1518             :            ! with "fast" version which just calls triangular solver.
    1519             :            !
    1520             :            ! This performance penalty is insignificant  when compared with
    1521             :            ! cost of large LU decomposition.  However,  if you  call  this
    1522             :            ! function many times for the same  left  side,  this  overhead
    1523             :            ! BECOMES significant. It  also  becomes significant for small-
    1524             :            ! scale problems.
    1525             :            !
    1526             :            ! In such cases we strongly recommend you to use faster solver,
    1527             :            ! CMatrixLUSolveFast() function.
    1528             : 
    1529             : INPUT PARAMETERS
    1530             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    1531             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    1532             :     N       -   size of A
    1533             :     B       -   array[0..N-1], right part
    1534             : 
    1535             : OUTPUT PARAMETERS
    1536             :     Info    -   return code:
    1537             :                 * -3    matrix is very badly conditioned or exactly singular.
    1538             :                 * -1    N<=0 was passed
    1539             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1540             :                         check R1/RInf parameters for condition numbers).
    1541             :     Rep     -   additional report, following fields are set:
    1542             :                 * rep.r1    condition number in 1-norm
    1543             :                 * rep.rinf  condition number in inf-norm
    1544             :     X       -   array[N], it contains:
    1545             :                 * info>0    =>  solution
    1546             :                 * info=-3   =>  filled by zeros
    1547             : 
    1548             :   -- ALGLIB --
    1549             :      Copyright 27.01.2010 by Bochkanov Sergey
    1550             : *************************************************************************/
    1551           0 : 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)
    1552             : {
    1553             :     jmp_buf _break_jump;
    1554             :     alglib_impl::ae_state _alglib_env_state;
    1555           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1556           0 :     if( setjmp(_break_jump) )
    1557             :     {
    1558             : #if !defined(AE_NO_EXCEPTIONS)
    1559           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1560             : #else
    1561             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1562             :         return;
    1563             : #endif
    1564             :     }
    1565           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1566           0 :     if( _xparams.flags!=0x0 )
    1567           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1568           0 :     alglib_impl::cmatrixlusolve(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    1569           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1570           0 :     return;
    1571             : }
    1572             : 
    1573             : /*************************************************************************
    1574             : Complex dense linear solver for A*x=b with N*N complex A given by  its  LU
    1575             : decomposition and N*1 vectors x and b. This is  fast  lightweight  version
    1576             : of solver, which is significantly faster than CMatrixLUSolve(),  but  does
    1577             : not provide additional information (like condition numbers).
    1578             : 
    1579             : Algorithm features:
    1580             : * O(N^2) complexity
    1581             : * no additional time-consuming features, just triangular solver
    1582             : 
    1583             : INPUT PARAMETERS
    1584             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    1585             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    1586             :     N       -   size of A
    1587             :     B       -   array[0..N-1], right part
    1588             : 
    1589             : OUTPUT PARAMETERS
    1590             :     Info    -   return code:
    1591             :                 * -3    matrix is exactly singular (ill conditioned matrices
    1592             :                         are not recognized).
    1593             :                 * -1    N<=0 was passed
    1594             :                 *  1    task is solved
    1595             :     B       -   array[N]:
    1596             :                 * info>0    =>  overwritten by solution
    1597             :                 * info=-3   =>  filled by zeros
    1598             : 
    1599             : NOTE: unlike  CMatrixLUSolve(),  this   function   does   NOT   check  for
    1600             :       near-degeneracy of input matrix. It  checks  for  EXACT  degeneracy,
    1601             :       because this check is easy to do. However,  very  badly  conditioned
    1602             :       matrices may went unnoticed.
    1603             : 
    1604             : 
    1605             :   -- ALGLIB --
    1606             :      Copyright 27.01.2010 by Bochkanov Sergey
    1607             : *************************************************************************/
    1608           0 : 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)
    1609             : {
    1610             :     jmp_buf _break_jump;
    1611             :     alglib_impl::ae_state _alglib_env_state;
    1612           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1613           0 :     if( setjmp(_break_jump) )
    1614             :     {
    1615             : #if !defined(AE_NO_EXCEPTIONS)
    1616           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1617             : #else
    1618             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1619             :         return;
    1620             : #endif
    1621             :     }
    1622           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1623           0 :     if( _xparams.flags!=0x0 )
    1624           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1625           0 :     alglib_impl::cmatrixlusolvefast(const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
    1626           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1627           0 :     return;
    1628             : }
    1629             : 
    1630             : /*************************************************************************
    1631             : Dense solver. Same as RMatrixMixedSolveM(), but for complex matrices.
    1632             : 
    1633             : Algorithm features:
    1634             : * automatic detection of degenerate cases
    1635             : * condition number estimation
    1636             : * iterative refinement
    1637             : * O(M*N^2) complexity
    1638             : 
    1639             : INPUT PARAMETERS
    1640             :     A       -   array[0..N-1,0..N-1], system matrix
    1641             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    1642             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    1643             :     N       -   size of A
    1644             :     B       -   array[0..N-1,0..M-1], right part
    1645             :     M       -   right part size
    1646             : 
    1647             : OUTPUT PARAMETERS
    1648             :     Info    -   return code:
    1649             :                 * -3    matrix is very badly conditioned or exactly singular.
    1650             :                 * -1    N<=0 was passed
    1651             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1652             :                         check R1/RInf parameters for condition numbers).
    1653             :     Rep     -   additional report, following fields are set:
    1654             :                 * rep.r1    condition number in 1-norm
    1655             :                 * rep.rinf  condition number in inf-norm
    1656             :     X       -   array[N,M], it contains:
    1657             :                 * info>0    =>  solution
    1658             :                 * info=-3   =>  filled by zeros
    1659             : 
    1660             :   -- ALGLIB --
    1661             :      Copyright 27.01.2010 by Bochkanov Sergey
    1662             : *************************************************************************/
    1663           0 : 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)
    1664             : {
    1665             :     jmp_buf _break_jump;
    1666             :     alglib_impl::ae_state _alglib_env_state;
    1667           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1668           0 :     if( setjmp(_break_jump) )
    1669             :     {
    1670             : #if !defined(AE_NO_EXCEPTIONS)
    1671           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1672             : #else
    1673             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1674             :         return;
    1675             : #endif
    1676             :     }
    1677           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1678           0 :     if( _xparams.flags!=0x0 )
    1679           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1680           0 :     alglib_impl::cmatrixmixedsolvem(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    1681           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1682           0 :     return;
    1683             : }
    1684             : 
    1685             : /*************************************************************************
    1686             : Dense solver. Same as RMatrixMixedSolve(), but for complex matrices.
    1687             : 
    1688             : Algorithm features:
    1689             : * automatic detection of degenerate cases
    1690             : * condition number estimation
    1691             : * iterative refinement
    1692             : * O(N^2) complexity
    1693             : 
    1694             : INPUT PARAMETERS
    1695             :     A       -   array[0..N-1,0..N-1], system matrix
    1696             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    1697             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    1698             :     N       -   size of A
    1699             :     B       -   array[0..N-1], right part
    1700             : 
    1701             : OUTPUT PARAMETERS
    1702             :     Info    -   return code:
    1703             :                 * -3    matrix is very badly conditioned or exactly singular.
    1704             :                 * -1    N<=0 was passed
    1705             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1706             :                         check R1/RInf parameters for condition numbers).
    1707             :     Rep     -   additional report, following fields are set:
    1708             :                 * rep.r1    condition number in 1-norm
    1709             :                 * rep.rinf  condition number in inf-norm
    1710             :     X       -   array[N], it contains:
    1711             :                 * info>0    =>  solution
    1712             :                 * info=-3   =>  filled by zeros
    1713             : 
    1714             :   -- ALGLIB --
    1715             :      Copyright 27.01.2010 by Bochkanov Sergey
    1716             : *************************************************************************/
    1717           0 : 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)
    1718             : {
    1719             :     jmp_buf _break_jump;
    1720             :     alglib_impl::ae_state _alglib_env_state;
    1721           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1722           0 :     if( setjmp(_break_jump) )
    1723             :     {
    1724             : #if !defined(AE_NO_EXCEPTIONS)
    1725           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1726             : #else
    1727             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1728             :         return;
    1729             : #endif
    1730             :     }
    1731           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1732           0 :     if( _xparams.flags!=0x0 )
    1733           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1734           0 :     alglib_impl::cmatrixmixedsolve(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), const_cast<alglib_impl::ae_matrix*>(lua.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    1735           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1736           0 :     return;
    1737             : }
    1738             : 
    1739             : /*************************************************************************
    1740             : Dense solver for A*X=B with N*N symmetric positive definite matrix A,  and
    1741             : N*M vectors X and B. It is "slow-but-feature-rich" version of the solver.
    1742             : 
    1743             : Algorithm features:
    1744             : * automatic detection of degenerate cases
    1745             : * condition number estimation
    1746             : * O(N^3+M*N^2) complexity
    1747             : * matrix is represented by its upper or lower triangle
    1748             : 
    1749             : No iterative refinement is provided because such partial representation of
    1750             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    1751             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    1752             : need iterative refinement.
    1753             : 
    1754             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    1755             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    1756             :            ! which  results  in  significant   performance   penalty  when
    1757             :            ! compared with "fast" version  which  just  performs  Cholesky
    1758             :            ! decomposition and calls triangular solver.
    1759             :            !
    1760             :            ! This  performance  penalty  is  especially  visible  in   the
    1761             :            ! multithreaded mode, because both condition number  estimation
    1762             :            ! and   iterative    refinement   are   inherently   sequential
    1763             :            ! calculations.
    1764             :            !
    1765             :            ! Thus, if you need high performance and if you are pretty sure
    1766             :            ! that your system is well conditioned, we  strongly  recommend
    1767             :            ! you to use faster solver, SPDMatrixSolveMFast() function.
    1768             : 
    1769             :   ! COMMERCIAL EDITION OF ALGLIB:
    1770             :   !
    1771             :   ! Commercial Edition of ALGLIB includes following important improvements
    1772             :   ! of this function:
    1773             :   ! * high-performance native backend with same C# interface (C# version)
    1774             :   ! * multithreading support (C++ and C# versions)
    1775             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1776             :   !   (C++ and C# versions, x86/x64 platform)
    1777             :   !
    1778             :   ! We recommend you to read 'Working with commercial version' section  of
    1779             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1780             :   ! related features provided by commercial edition of ALGLIB.
    1781             : 
    1782             : INPUT PARAMETERS
    1783             :     A       -   array[0..N-1,0..N-1], system matrix
    1784             :     N       -   size of A
    1785             :     IsUpper -   what half of A is provided
    1786             :     B       -   array[0..N-1,0..M-1], right part
    1787             :     M       -   right part size
    1788             : 
    1789             : OUTPUT PARAMETERS
    1790             :     Info    -   return code:
    1791             :                 * -3    matrix is very badly conditioned or non-SPD.
    1792             :                 * -1    N<=0 was passed
    1793             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1794             :                         check R1/RInf parameters for condition numbers).
    1795             :     Rep     -   additional report, following fields are set:
    1796             :                 * rep.r1    condition number in 1-norm
    1797             :                 * rep.rinf  condition number in inf-norm
    1798             :     X       -   array[N,M], it contains:
    1799             :                 * info>0    =>  solution
    1800             :                 * info=-3   =>  filled by zeros
    1801             : 
    1802             :   -- ALGLIB --
    1803             :      Copyright 27.01.2010 by Bochkanov Sergey
    1804             : *************************************************************************/
    1805           0 : 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)
    1806             : {
    1807             :     jmp_buf _break_jump;
    1808             :     alglib_impl::ae_state _alglib_env_state;
    1809           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1810           0 :     if( setjmp(_break_jump) )
    1811             :     {
    1812             : #if !defined(AE_NO_EXCEPTIONS)
    1813           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1814             : #else
    1815             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1816             :         return;
    1817             : #endif
    1818             :     }
    1819           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1820           0 :     if( _xparams.flags!=0x0 )
    1821           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1822           0 :     alglib_impl::spdmatrixsolvem(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    1823           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1824           0 :     return;
    1825             : }
    1826             : 
    1827             : /*************************************************************************
    1828             : Dense solver for A*X=B with N*N symmetric positive definite matrix A,  and
    1829             : N*M vectors X and B. It is "fast-but-lightweight" version of the solver.
    1830             : 
    1831             : Algorithm features:
    1832             : * O(N^3+M*N^2) complexity
    1833             : * matrix is represented by its upper or lower triangle
    1834             : * no additional time consuming features
    1835             : 
    1836             :   ! COMMERCIAL EDITION OF ALGLIB:
    1837             :   !
    1838             :   ! Commercial Edition of ALGLIB includes following important improvements
    1839             :   ! of this function:
    1840             :   ! * high-performance native backend with same C# interface (C# version)
    1841             :   ! * multithreading support (C++ and C# versions)
    1842             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1843             :   !   (C++ and C# versions, x86/x64 platform)
    1844             :   !
    1845             :   ! We recommend you to read 'Working with commercial version' section  of
    1846             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1847             :   ! related features provided by commercial edition of ALGLIB.
    1848             : 
    1849             : INPUT PARAMETERS
    1850             :     A       -   array[0..N-1,0..N-1], system matrix
    1851             :     N       -   size of A
    1852             :     IsUpper -   what half of A is provided
    1853             :     B       -   array[0..N-1,0..M-1], right part
    1854             :     M       -   right part size
    1855             : 
    1856             : OUTPUT PARAMETERS
    1857             :     Info    -   return code:
    1858             :                 * -3    A is is exactly singular
    1859             :                 * -1    N<=0 was passed
    1860             :                 *  1    task was solved
    1861             :     B       -   array[N,M], it contains:
    1862             :                 * info>0    =>  solution
    1863             :                 * info=-3   =>  filled by zeros
    1864             : 
    1865             :   -- ALGLIB --
    1866             :      Copyright 17.03.2015 by Bochkanov Sergey
    1867             : *************************************************************************/
    1868           0 : 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)
    1869             : {
    1870             :     jmp_buf _break_jump;
    1871             :     alglib_impl::ae_state _alglib_env_state;
    1872           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1873           0 :     if( setjmp(_break_jump) )
    1874             :     {
    1875             : #if !defined(AE_NO_EXCEPTIONS)
    1876           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1877             : #else
    1878             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1879             :         return;
    1880             : #endif
    1881             :     }
    1882           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1883           0 :     if( _xparams.flags!=0x0 )
    1884           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1885           0 :     alglib_impl::spdmatrixsolvemfast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
    1886           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1887           0 :     return;
    1888             : }
    1889             : 
    1890             : /*************************************************************************
    1891             : Dense linear solver for A*x=b with N*N real  symmetric  positive  definite
    1892             : matrix A,  N*1 vectors x and b.  "Slow-but-feature-rich"  version  of  the
    1893             : solver.
    1894             : 
    1895             : Algorithm features:
    1896             : * automatic detection of degenerate cases
    1897             : * condition number estimation
    1898             : * O(N^3) complexity
    1899             : * matrix is represented by its upper or lower triangle
    1900             : 
    1901             : No iterative refinement is provided because such partial representation of
    1902             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    1903             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    1904             : need iterative refinement.
    1905             : 
    1906             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    1907             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    1908             :            ! which  results  in  significant   performance   penalty  when
    1909             :            ! compared with "fast" version  which  just  performs  Cholesky
    1910             :            ! decomposition and calls triangular solver.
    1911             :            !
    1912             :            ! This  performance  penalty  is  especially  visible  in   the
    1913             :            ! multithreaded mode, because both condition number  estimation
    1914             :            ! and   iterative    refinement   are   inherently   sequential
    1915             :            ! calculations.
    1916             :            !
    1917             :            ! Thus, if you need high performance and if you are pretty sure
    1918             :            ! that your system is well conditioned, we  strongly  recommend
    1919             :            ! you to use faster solver, SPDMatrixSolveFast() function.
    1920             : 
    1921             :   ! COMMERCIAL EDITION OF ALGLIB:
    1922             :   !
    1923             :   ! Commercial Edition of ALGLIB includes following important improvements
    1924             :   ! of this function:
    1925             :   ! * high-performance native backend with same C# interface (C# version)
    1926             :   ! * multithreading support (C++ and C# versions)
    1927             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1928             :   !   (C++ and C# versions, x86/x64 platform)
    1929             :   !
    1930             :   ! We recommend you to read 'Working with commercial version' section  of
    1931             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1932             :   ! related features provided by commercial edition of ALGLIB.
    1933             : 
    1934             : INPUT PARAMETERS
    1935             :     A       -   array[0..N-1,0..N-1], system matrix
    1936             :     N       -   size of A
    1937             :     IsUpper -   what half of A is provided
    1938             :     B       -   array[0..N-1], right part
    1939             : 
    1940             : OUTPUT PARAMETERS
    1941             :     Info    -   return code:
    1942             :                 * -3    matrix is very badly conditioned or non-SPD.
    1943             :                 * -1    N<=0 was passed
    1944             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    1945             :                         check R1/RInf parameters for condition numbers).
    1946             :     Rep     -   additional report, following fields are set:
    1947             :                 * rep.r1    condition number in 1-norm
    1948             :                 * rep.rinf  condition number in inf-norm
    1949             :     X       -   array[N], it contains:
    1950             :                 * info>0    =>  solution
    1951             :                 * info=-3   =>  filled by zeros
    1952             : 
    1953             :   -- ALGLIB --
    1954             :      Copyright 27.01.2010 by Bochkanov Sergey
    1955             : *************************************************************************/
    1956           0 : 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)
    1957             : {
    1958             :     jmp_buf _break_jump;
    1959             :     alglib_impl::ae_state _alglib_env_state;
    1960           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    1961           0 :     if( setjmp(_break_jump) )
    1962             :     {
    1963             : #if !defined(AE_NO_EXCEPTIONS)
    1964           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    1965             : #else
    1966             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    1967             :         return;
    1968             : #endif
    1969             :     }
    1970           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    1971           0 :     if( _xparams.flags!=0x0 )
    1972           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    1973           0 :     alglib_impl::spdmatrixsolve(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    1974           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    1975           0 :     return;
    1976             : }
    1977             : 
    1978             : /*************************************************************************
    1979             : Dense linear solver for A*x=b with N*N real  symmetric  positive  definite
    1980             : matrix A,  N*1 vectors x and  b.  "Fast-but-lightweight"  version  of  the
    1981             : solver.
    1982             : 
    1983             : Algorithm features:
    1984             : * O(N^3) complexity
    1985             : * matrix is represented by its upper or lower triangle
    1986             : * no additional time consuming features like condition number estimation
    1987             : 
    1988             :   ! COMMERCIAL EDITION OF ALGLIB:
    1989             :   !
    1990             :   ! Commercial Edition of ALGLIB includes following important improvements
    1991             :   ! of this function:
    1992             :   ! * high-performance native backend with same C# interface (C# version)
    1993             :   ! * multithreading support (C++ and C# versions)
    1994             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    1995             :   !   (C++ and C# versions, x86/x64 platform)
    1996             :   !
    1997             :   ! We recommend you to read 'Working with commercial version' section  of
    1998             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    1999             :   ! related features provided by commercial edition of ALGLIB.
    2000             : 
    2001             : INPUT PARAMETERS
    2002             :     A       -   array[0..N-1,0..N-1], system matrix
    2003             :     N       -   size of A
    2004             :     IsUpper -   what half of A is provided
    2005             :     B       -   array[0..N-1], right part
    2006             : 
    2007             : OUTPUT PARAMETERS
    2008             :     Info    -   return code:
    2009             :                 * -3    A is is exactly singular or non-SPD
    2010             :                 * -1    N<=0 was passed
    2011             :                 *  1    task was solved
    2012             :     B       -   array[N], it contains:
    2013             :                 * info>0    =>  solution
    2014             :                 * info=-3   =>  filled by zeros
    2015             : 
    2016             :   -- ALGLIB --
    2017             :      Copyright 17.03.2015 by Bochkanov Sergey
    2018             : *************************************************************************/
    2019           0 : 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)
    2020             : {
    2021             :     jmp_buf _break_jump;
    2022             :     alglib_impl::ae_state _alglib_env_state;
    2023           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2024           0 :     if( setjmp(_break_jump) )
    2025             :     {
    2026             : #if !defined(AE_NO_EXCEPTIONS)
    2027           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2028             : #else
    2029             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2030             :         return;
    2031             : #endif
    2032             :     }
    2033           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2034           0 :     if( _xparams.flags!=0x0 )
    2035           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2036           0 :     alglib_impl::spdmatrixsolvefast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
    2037           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2038           0 :     return;
    2039             : }
    2040             : 
    2041             : /*************************************************************************
    2042             : Dense solver for A*X=B with N*N symmetric positive definite matrix A given
    2043             : by its Cholesky decomposition, and N*M vectors X and B. It  is  "slow-but-
    2044             : feature-rich" version of the solver which estimates  condition  number  of
    2045             : the system.
    2046             : 
    2047             : Algorithm features:
    2048             : * automatic detection of degenerate cases
    2049             : * O(M*N^2) complexity
    2050             : * condition number estimation
    2051             : * matrix is represented by its upper or lower triangle
    2052             : 
    2053             : No iterative refinement is provided because such partial representation of
    2054             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    2055             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    2056             : need iterative refinement.
    2057             : 
    2058             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    2059             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    2060             :            ! which  results  in  significant  performance   penalty   when
    2061             :            ! compared with "fast"  version  which  just  calls  triangular
    2062             :            ! solver. Amount of  overhead  introduced  depends  on  M  (the
    2063             :            ! larger - the more efficient).
    2064             :            !
    2065             :            ! This performance penalty is insignificant  when compared with
    2066             :            ! cost of large LU decomposition.  However,  if you  call  this
    2067             :            ! function many times for the same  left  side,  this  overhead
    2068             :            ! BECOMES significant. It  also  becomes significant for small-
    2069             :            ! scale problems (N<50).
    2070             :            !
    2071             :            ! In such cases we strongly recommend you to use faster solver,
    2072             :            ! SPDMatrixCholeskySolveMFast() function.
    2073             : 
    2074             : INPUT PARAMETERS
    2075             :     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,
    2076             :                 SPDMatrixCholesky result
    2077             :     N       -   size of CHA
    2078             :     IsUpper -   what half of CHA is provided
    2079             :     B       -   array[0..N-1,0..M-1], right part
    2080             :     M       -   right part size
    2081             : 
    2082             : OUTPUT PARAMETERS
    2083             :     Info    -   return code:
    2084             :                 * -3    A is is exactly singular or badly conditioned
    2085             :                         X is filled by zeros in such cases.
    2086             :                 * -1    N<=0 was passed
    2087             :                 *  1    task was solved
    2088             :     Rep     -   additional report, following fields are set:
    2089             :                 * rep.r1    condition number in 1-norm
    2090             :                 * rep.rinf  condition number in inf-norm
    2091             :     X       -   array[N]:
    2092             :                 * for info>0 contains solution
    2093             :                 * for info=-3 filled by zeros
    2094             : 
    2095             :   -- ALGLIB --
    2096             :      Copyright 27.01.2010 by Bochkanov Sergey
    2097             : *************************************************************************/
    2098           0 : 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)
    2099             : {
    2100             :     jmp_buf _break_jump;
    2101             :     alglib_impl::ae_state _alglib_env_state;
    2102           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2103           0 :     if( setjmp(_break_jump) )
    2104             :     {
    2105             : #if !defined(AE_NO_EXCEPTIONS)
    2106           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2107             : #else
    2108             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2109             :         return;
    2110             : #endif
    2111             :     }
    2112           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2113           0 :     if( _xparams.flags!=0x0 )
    2114           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2115           0 :     alglib_impl::spdmatrixcholeskysolvem(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    2116           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2117           0 :     return;
    2118             : }
    2119             : 
    2120             : /*************************************************************************
    2121             : Dense solver for A*X=B with N*N symmetric positive definite matrix A given
    2122             : by its Cholesky decomposition, and N*M vectors X and B. It  is  "fast-but-
    2123             : lightweight" version of  the  solver  which  just  solves  linear  system,
    2124             : without any additional functions.
    2125             : 
    2126             : Algorithm features:
    2127             : * O(M*N^2) complexity
    2128             : * matrix is represented by its upper or lower triangle
    2129             : * no additional functionality
    2130             : 
    2131             : INPUT PARAMETERS
    2132             :     CHA     -   array[N,N], Cholesky decomposition,
    2133             :                 SPDMatrixCholesky result
    2134             :     N       -   size of CHA
    2135             :     IsUpper -   what half of CHA is provided
    2136             :     B       -   array[N,M], right part
    2137             :     M       -   right part size
    2138             : 
    2139             : OUTPUT PARAMETERS
    2140             :     Info    -   return code:
    2141             :                 * -3    A is is exactly singular or badly conditioned
    2142             :                         X is filled by zeros in such cases.
    2143             :                 * -1    N<=0 was passed
    2144             :                 *  1    task was solved
    2145             :     B       -   array[N]:
    2146             :                 * for info>0 overwritten by solution
    2147             :                 * for info=-3 filled by zeros
    2148             : 
    2149             :   -- ALGLIB --
    2150             :      Copyright 18.03.2015 by Bochkanov Sergey
    2151             : *************************************************************************/
    2152           0 : 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)
    2153             : {
    2154             :     jmp_buf _break_jump;
    2155             :     alglib_impl::ae_state _alglib_env_state;
    2156           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2157           0 :     if( setjmp(_break_jump) )
    2158             :     {
    2159             : #if !defined(AE_NO_EXCEPTIONS)
    2160           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2161             : #else
    2162             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2163             :         return;
    2164             : #endif
    2165             :     }
    2166           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2167           0 :     if( _xparams.flags!=0x0 )
    2168           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2169           0 :     alglib_impl::spdmatrixcholeskysolvemfast(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
    2170           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2171           0 :     return;
    2172             : }
    2173             : 
    2174             : /*************************************************************************
    2175             : Dense solver for A*x=b with N*N symmetric positive definite matrix A given
    2176             : by its Cholesky decomposition, and N*1 real vectors x and b. This is "slow-
    2177             : but-feature-rich"  version  of  the  solver  which,  in  addition  to  the
    2178             : solution, performs condition number estimation.
    2179             : 
    2180             : Algorithm features:
    2181             : * automatic detection of degenerate cases
    2182             : * O(N^2) complexity
    2183             : * condition number estimation
    2184             : * matrix is represented by its upper or lower triangle
    2185             : 
    2186             : No iterative refinement is provided because such partial representation of
    2187             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    2188             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    2189             : need iterative refinement.
    2190             : 
    2191             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    2192             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    2193             :            ! which results in 10-15x  performance  penalty  when  compared
    2194             :            ! with "fast" version which just calls triangular solver.
    2195             :            !
    2196             :            ! This performance penalty is insignificant  when compared with
    2197             :            ! cost of large LU decomposition.  However,  if you  call  this
    2198             :            ! function many times for the same  left  side,  this  overhead
    2199             :            ! BECOMES significant. It  also  becomes significant for small-
    2200             :            ! scale problems (N<50).
    2201             :            !
    2202             :            ! In such cases we strongly recommend you to use faster solver,
    2203             :            ! SPDMatrixCholeskySolveFast() function.
    2204             : 
    2205             : INPUT PARAMETERS
    2206             :     CHA     -   array[N,N], Cholesky decomposition,
    2207             :                 SPDMatrixCholesky result
    2208             :     N       -   size of A
    2209             :     IsUpper -   what half of CHA is provided
    2210             :     B       -   array[N], right part
    2211             : 
    2212             : OUTPUT PARAMETERS
    2213             :     Info    -   return code:
    2214             :                 * -3    A is is exactly singular or ill conditioned
    2215             :                         X is filled by zeros in such cases.
    2216             :                 * -1    N<=0 was passed
    2217             :                 *  1    task is solved
    2218             :     Rep     -   additional report, following fields are set:
    2219             :                 * rep.r1    condition number in 1-norm
    2220             :                 * rep.rinf  condition number in inf-norm
    2221             :     X       -   array[N]:
    2222             :                 * for info>0  - solution
    2223             :                 * for info=-3 - filled by zeros
    2224             : 
    2225             :   -- ALGLIB --
    2226             :      Copyright 27.01.2010 by Bochkanov Sergey
    2227             : *************************************************************************/
    2228           0 : 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)
    2229             : {
    2230             :     jmp_buf _break_jump;
    2231             :     alglib_impl::ae_state _alglib_env_state;
    2232           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2233           0 :     if( setjmp(_break_jump) )
    2234             :     {
    2235             : #if !defined(AE_NO_EXCEPTIONS)
    2236           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2237             : #else
    2238             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2239             :         return;
    2240             : #endif
    2241             :     }
    2242           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2243           0 :     if( _xparams.flags!=0x0 )
    2244           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2245           0 :     alglib_impl::spdmatrixcholeskysolve(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    2246           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2247           0 :     return;
    2248             : }
    2249             : 
    2250             : /*************************************************************************
    2251             : Dense solver for A*x=b with N*N symmetric positive definite matrix A given
    2252             : by its Cholesky decomposition, and N*1 real vectors x and b. This is "fast-
    2253             : but-lightweight" version of the solver.
    2254             : 
    2255             : Algorithm features:
    2256             : * O(N^2) complexity
    2257             : * matrix is represented by its upper or lower triangle
    2258             : * no additional features
    2259             : 
    2260             : INPUT PARAMETERS
    2261             :     CHA     -   array[N,N], Cholesky decomposition,
    2262             :                 SPDMatrixCholesky result
    2263             :     N       -   size of A
    2264             :     IsUpper -   what half of CHA is provided
    2265             :     B       -   array[N], right part
    2266             : 
    2267             : OUTPUT PARAMETERS
    2268             :     Info    -   return code:
    2269             :                 * -3    A is is exactly singular or ill conditioned
    2270             :                         X is filled by zeros in such cases.
    2271             :                 * -1    N<=0 was passed
    2272             :                 *  1    task is solved
    2273             :     B       -   array[N]:
    2274             :                 * for info>0  - overwritten by solution
    2275             :                 * for info=-3 - filled by zeros
    2276             : 
    2277             :   -- ALGLIB --
    2278             :      Copyright 27.01.2010 by Bochkanov Sergey
    2279             : *************************************************************************/
    2280           0 : 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)
    2281             : {
    2282             :     jmp_buf _break_jump;
    2283             :     alglib_impl::ae_state _alglib_env_state;
    2284           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2285           0 :     if( setjmp(_break_jump) )
    2286             :     {
    2287             : #if !defined(AE_NO_EXCEPTIONS)
    2288           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2289             : #else
    2290             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2291             :         return;
    2292             : #endif
    2293             :     }
    2294           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2295           0 :     if( _xparams.flags!=0x0 )
    2296           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2297           0 :     alglib_impl::spdmatrixcholeskysolvefast(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
    2298           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2299           0 :     return;
    2300             : }
    2301             : 
    2302             : /*************************************************************************
    2303             : Dense solver for A*X=B, with N*N Hermitian positive definite matrix A  and
    2304             : N*M  complex  matrices  X  and  B.  "Slow-but-feature-rich" version of the
    2305             : solver.
    2306             : 
    2307             : Algorithm features:
    2308             : * automatic detection of degenerate cases
    2309             : * condition number estimation
    2310             : * O(N^3+M*N^2) complexity
    2311             : * matrix is represented by its upper or lower triangle
    2312             : 
    2313             : No iterative refinement is provided because such partial representation of
    2314             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    2315             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    2316             : need iterative refinement.
    2317             : 
    2318             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    2319             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    2320             :            ! which  results  in  significant  performance   penalty   when
    2321             :            ! compared with "fast"  version  which  just  calls  triangular
    2322             :            ! solver.
    2323             :            !
    2324             :            ! This performance penalty is especially apparent when you  use
    2325             :            ! ALGLIB parallel capabilities (condition number estimation  is
    2326             :            ! inherently  sequential).  It   also   becomes significant for
    2327             :            ! small-scale problems (N<100).
    2328             :            !
    2329             :            ! In such cases we strongly recommend you to use faster solver,
    2330             :            ! HPDMatrixSolveMFast() function.
    2331             : 
    2332             :   ! COMMERCIAL EDITION OF ALGLIB:
    2333             :   !
    2334             :   ! Commercial Edition of ALGLIB includes following important improvements
    2335             :   ! of this function:
    2336             :   ! * high-performance native backend with same C# interface (C# version)
    2337             :   ! * multithreading support (C++ and C# versions)
    2338             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    2339             :   !   (C++ and C# versions, x86/x64 platform)
    2340             :   !
    2341             :   ! We recommend you to read 'Working with commercial version' section  of
    2342             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    2343             :   ! related features provided by commercial edition of ALGLIB.
    2344             : 
    2345             : INPUT PARAMETERS
    2346             :     A       -   array[0..N-1,0..N-1], system matrix
    2347             :     N       -   size of A
    2348             :     IsUpper -   what half of A is provided
    2349             :     B       -   array[0..N-1,0..M-1], right part
    2350             :     M       -   right part size
    2351             : 
    2352             : OUTPUT PARAMETERS
    2353             :     Info    -   same as in RMatrixSolve.
    2354             :                 Returns -3 for non-HPD matrices.
    2355             :     Rep     -   same as in RMatrixSolve
    2356             :     X       -   same as in RMatrixSolve
    2357             : 
    2358             :   -- ALGLIB --
    2359             :      Copyright 27.01.2010 by Bochkanov Sergey
    2360             : *************************************************************************/
    2361           0 : 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)
    2362             : {
    2363             :     jmp_buf _break_jump;
    2364             :     alglib_impl::ae_state _alglib_env_state;
    2365           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2366           0 :     if( setjmp(_break_jump) )
    2367             :     {
    2368             : #if !defined(AE_NO_EXCEPTIONS)
    2369           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2370             : #else
    2371             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2372             :         return;
    2373             : #endif
    2374             :     }
    2375           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2376           0 :     if( _xparams.flags!=0x0 )
    2377           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2378           0 :     alglib_impl::hpdmatrixsolvem(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    2379           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2380           0 :     return;
    2381             : }
    2382             : 
    2383             : /*************************************************************************
    2384             : Dense solver for A*X=B, with N*N Hermitian positive definite matrix A  and
    2385             : N*M complex matrices X and B. "Fast-but-lightweight" version of the solver.
    2386             : 
    2387             : Algorithm features:
    2388             : * O(N^3+M*N^2) complexity
    2389             : * matrix is represented by its upper or lower triangle
    2390             : * no additional time consuming features like condition number estimation
    2391             : 
    2392             :   ! COMMERCIAL EDITION OF ALGLIB:
    2393             :   !
    2394             :   ! Commercial Edition of ALGLIB includes following important improvements
    2395             :   ! of this function:
    2396             :   ! * high-performance native backend with same C# interface (C# version)
    2397             :   ! * multithreading support (C++ and C# versions)
    2398             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    2399             :   !   (C++ and C# versions, x86/x64 platform)
    2400             :   !
    2401             :   ! We recommend you to read 'Working with commercial version' section  of
    2402             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    2403             :   ! related features provided by commercial edition of ALGLIB.
    2404             : 
    2405             : INPUT PARAMETERS
    2406             :     A       -   array[0..N-1,0..N-1], system matrix
    2407             :     N       -   size of A
    2408             :     IsUpper -   what half of A is provided
    2409             :     B       -   array[0..N-1,0..M-1], right part
    2410             :     M       -   right part size
    2411             : 
    2412             : OUTPUT PARAMETERS
    2413             :     Info    -   return code:
    2414             :                 * -3    A is is exactly  singular or is not positive definite.
    2415             :                         B is filled by zeros in such cases.
    2416             :                 * -1    N<=0 was passed
    2417             :                 *  1    task is solved
    2418             :     B       -   array[0..N-1]:
    2419             :                 * overwritten by solution
    2420             :                 * zeros, if problem was not solved
    2421             : 
    2422             :   -- ALGLIB --
    2423             :      Copyright 17.03.2015 by Bochkanov Sergey
    2424             : *************************************************************************/
    2425           0 : 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)
    2426             : {
    2427             :     jmp_buf _break_jump;
    2428             :     alglib_impl::ae_state _alglib_env_state;
    2429           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2430           0 :     if( setjmp(_break_jump) )
    2431             :     {
    2432             : #if !defined(AE_NO_EXCEPTIONS)
    2433           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2434             : #else
    2435             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2436             :         return;
    2437             : #endif
    2438             :     }
    2439           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2440           0 :     if( _xparams.flags!=0x0 )
    2441           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2442           0 :     alglib_impl::hpdmatrixsolvemfast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
    2443           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2444           0 :     return;
    2445             : }
    2446             : 
    2447             : /*************************************************************************
    2448             : Dense solver for A*x=b, with N*N Hermitian positive definite matrix A, and
    2449             : N*1 complex vectors  x  and  b.  "Slow-but-feature-rich"  version  of  the
    2450             : solver.
    2451             : 
    2452             : Algorithm features:
    2453             : * automatic detection of degenerate cases
    2454             : * condition number estimation
    2455             : * O(N^3) complexity
    2456             : * matrix is represented by its upper or lower triangle
    2457             : 
    2458             : No iterative refinement is provided because such partial representation of
    2459             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    2460             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    2461             : need iterative refinement.
    2462             : 
    2463             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    2464             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    2465             :            ! which  results  in  significant   performance   penalty  when
    2466             :            ! compared with "fast" version  which  just  performs  Cholesky
    2467             :            ! decomposition and calls triangular solver.
    2468             :            !
    2469             :            ! This  performance  penalty  is  especially  visible  in   the
    2470             :            ! multithreaded mode, because both condition number  estimation
    2471             :            ! and   iterative    refinement   are   inherently   sequential
    2472             :            ! calculations.
    2473             :            !
    2474             :            ! Thus, if you need high performance and if you are pretty sure
    2475             :            ! that your system is well conditioned, we  strongly  recommend
    2476             :            ! you to use faster solver, HPDMatrixSolveFast() function.
    2477             : 
    2478             :   ! COMMERCIAL EDITION OF ALGLIB:
    2479             :   !
    2480             :   ! Commercial Edition of ALGLIB includes following important improvements
    2481             :   ! of this function:
    2482             :   ! * high-performance native backend with same C# interface (C# version)
    2483             :   ! * multithreading support (C++ and C# versions)
    2484             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    2485             :   !   (C++ and C# versions, x86/x64 platform)
    2486             :   !
    2487             :   ! We recommend you to read 'Working with commercial version' section  of
    2488             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    2489             :   ! related features provided by commercial edition of ALGLIB.
    2490             : 
    2491             : INPUT PARAMETERS
    2492             :     A       -   array[0..N-1,0..N-1], system matrix
    2493             :     N       -   size of A
    2494             :     IsUpper -   what half of A is provided
    2495             :     B       -   array[0..N-1], right part
    2496             : 
    2497             : OUTPUT PARAMETERS
    2498             :     Info    -   same as in RMatrixSolve
    2499             :                 Returns -3 for non-HPD matrices.
    2500             :     Rep     -   same as in RMatrixSolve
    2501             :     X       -   same as in RMatrixSolve
    2502             : 
    2503             :   -- ALGLIB --
    2504             :      Copyright 27.01.2010 by Bochkanov Sergey
    2505             : *************************************************************************/
    2506           0 : 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)
    2507             : {
    2508             :     jmp_buf _break_jump;
    2509             :     alglib_impl::ae_state _alglib_env_state;
    2510           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2511           0 :     if( setjmp(_break_jump) )
    2512             :     {
    2513             : #if !defined(AE_NO_EXCEPTIONS)
    2514           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2515             : #else
    2516             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2517             :         return;
    2518             : #endif
    2519             :     }
    2520           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2521           0 :     if( _xparams.flags!=0x0 )
    2522           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2523           0 :     alglib_impl::hpdmatrixsolve(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    2524           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2525           0 :     return;
    2526             : }
    2527             : 
    2528             : /*************************************************************************
    2529             : Dense solver for A*x=b, with N*N Hermitian positive definite matrix A, and
    2530             : N*1 complex vectors  x  and  b.  "Fast-but-lightweight"  version  of   the
    2531             : solver without additional functions.
    2532             : 
    2533             : Algorithm features:
    2534             : * O(N^3) complexity
    2535             : * matrix is represented by its upper or lower triangle
    2536             : * no additional time consuming functions
    2537             : 
    2538             :   ! COMMERCIAL EDITION OF ALGLIB:
    2539             :   !
    2540             :   ! Commercial Edition of ALGLIB includes following important improvements
    2541             :   ! of this function:
    2542             :   ! * high-performance native backend with same C# interface (C# version)
    2543             :   ! * multithreading support (C++ and C# versions)
    2544             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    2545             :   !   (C++ and C# versions, x86/x64 platform)
    2546             :   !
    2547             :   ! We recommend you to read 'Working with commercial version' section  of
    2548             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    2549             :   ! related features provided by commercial edition of ALGLIB.
    2550             : 
    2551             : INPUT PARAMETERS
    2552             :     A       -   array[0..N-1,0..N-1], system matrix
    2553             :     N       -   size of A
    2554             :     IsUpper -   what half of A is provided
    2555             :     B       -   array[0..N-1], right part
    2556             : 
    2557             : OUTPUT PARAMETERS
    2558             :     Info    -   return code:
    2559             :                 * -3    A is is exactly singular or not positive definite
    2560             :                         X is filled by zeros in such cases.
    2561             :                 * -1    N<=0 was passed
    2562             :                 *  1    task was solved
    2563             :     B       -   array[0..N-1]:
    2564             :                 * overwritten by solution
    2565             :                 * zeros, if A is exactly singular (diagonal of its LU
    2566             :                   decomposition has exact zeros).
    2567             : 
    2568             :   -- ALGLIB --
    2569             :      Copyright 17.03.2015 by Bochkanov Sergey
    2570             : *************************************************************************/
    2571           0 : 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)
    2572             : {
    2573             :     jmp_buf _break_jump;
    2574             :     alglib_impl::ae_state _alglib_env_state;
    2575           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2576           0 :     if( setjmp(_break_jump) )
    2577             :     {
    2578             : #if !defined(AE_NO_EXCEPTIONS)
    2579           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2580             : #else
    2581             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2582             :         return;
    2583             : #endif
    2584             :     }
    2585           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2586           0 :     if( _xparams.flags!=0x0 )
    2587           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2588           0 :     alglib_impl::hpdmatrixsolvefast(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
    2589           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2590           0 :     return;
    2591             : }
    2592             : 
    2593             : /*************************************************************************
    2594             : Dense solver for A*X=B with N*N Hermitian positive definite matrix A given
    2595             : by its Cholesky decomposition and N*M complex matrices X  and  B.  This is
    2596             : "slow-but-feature-rich" version of the solver which, in  addition  to  the
    2597             : solution, estimates condition number of the system.
    2598             : 
    2599             : Algorithm features:
    2600             : * automatic detection of degenerate cases
    2601             : * O(M*N^2) complexity
    2602             : * condition number estimation
    2603             : * matrix is represented by its upper or lower triangle
    2604             : 
    2605             : No iterative refinement is provided because such partial representation of
    2606             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    2607             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    2608             : need iterative refinement.
    2609             : 
    2610             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    2611             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    2612             :            ! which  results  in  significant  performance   penalty   when
    2613             :            ! compared with "fast"  version  which  just  calls  triangular
    2614             :            ! solver. Amount of  overhead  introduced  depends  on  M  (the
    2615             :            ! larger - the more efficient).
    2616             :            !
    2617             :            ! This performance penalty is insignificant  when compared with
    2618             :            ! cost of large Cholesky decomposition.  However,  if  you call
    2619             :            ! this  function  many  times  for  the same  left  side,  this
    2620             :            ! overhead BECOMES significant. It  also   becomes  significant
    2621             :            ! for small-scale problems (N<50).
    2622             :            !
    2623             :            ! In such cases we strongly recommend you to use faster solver,
    2624             :            ! HPDMatrixCholeskySolveMFast() function.
    2625             : 
    2626             : 
    2627             : INPUT PARAMETERS
    2628             :     CHA     -   array[N,N], Cholesky decomposition,
    2629             :                 HPDMatrixCholesky result
    2630             :     N       -   size of CHA
    2631             :     IsUpper -   what half of CHA is provided
    2632             :     B       -   array[N,M], right part
    2633             :     M       -   right part size
    2634             : 
    2635             : OUTPUT PARAMETERS:
    2636             :     Info    -   return code:
    2637             :                 * -3    A is singular, or VERY close to singular.
    2638             :                         X is filled by zeros in such cases.
    2639             :                 * -1    N<=0 was passed
    2640             :                 *  1    task was solved
    2641             :     Rep     -   additional report, following fields are set:
    2642             :                 * rep.r1    condition number in 1-norm
    2643             :                 * rep.rinf  condition number in inf-norm
    2644             :     X       -   array[N]:
    2645             :                 * for info>0 contains solution
    2646             :                 * for info=-3 filled by zeros
    2647             : 
    2648             :   -- ALGLIB --
    2649             :      Copyright 27.01.2010 by Bochkanov Sergey
    2650             : *************************************************************************/
    2651           0 : 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)
    2652             : {
    2653             :     jmp_buf _break_jump;
    2654             :     alglib_impl::ae_state _alglib_env_state;
    2655           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2656           0 :     if( setjmp(_break_jump) )
    2657             :     {
    2658             : #if !defined(AE_NO_EXCEPTIONS)
    2659           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2660             : #else
    2661             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2662             :         return;
    2663             : #endif
    2664             :     }
    2665           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2666           0 :     if( _xparams.flags!=0x0 )
    2667           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2668           0 :     alglib_impl::hpdmatrixcholeskysolvem(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_matrix*>(x.c_ptr()), &_alglib_env_state);
    2669           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2670           0 :     return;
    2671             : }
    2672             : 
    2673             : /*************************************************************************
    2674             : Dense solver for A*X=B with N*N Hermitian positive definite matrix A given
    2675             : by its Cholesky decomposition and N*M complex matrices X  and  B.  This is
    2676             : "fast-but-lightweight" version of the solver.
    2677             : 
    2678             : Algorithm features:
    2679             : * O(M*N^2) complexity
    2680             : * matrix is represented by its upper or lower triangle
    2681             : * no additional time-consuming features
    2682             : 
    2683             : INPUT PARAMETERS
    2684             :     CHA     -   array[N,N], Cholesky decomposition,
    2685             :                 HPDMatrixCholesky result
    2686             :     N       -   size of CHA
    2687             :     IsUpper -   what half of CHA is provided
    2688             :     B       -   array[N,M], right part
    2689             :     M       -   right part size
    2690             : 
    2691             : OUTPUT PARAMETERS:
    2692             :     Info    -   return code:
    2693             :                 * -3    A is singular, or VERY close to singular.
    2694             :                         X is filled by zeros in such cases.
    2695             :                 * -1    N<=0 was passed
    2696             :                 *  1    task was solved
    2697             :     B       -   array[N]:
    2698             :                 * for info>0 overwritten by solution
    2699             :                 * for info=-3 filled by zeros
    2700             : 
    2701             :   -- ALGLIB --
    2702             :      Copyright 18.03.2015 by Bochkanov Sergey
    2703             : *************************************************************************/
    2704           0 : 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)
    2705             : {
    2706             :     jmp_buf _break_jump;
    2707             :     alglib_impl::ae_state _alglib_env_state;
    2708           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2709           0 :     if( setjmp(_break_jump) )
    2710             :     {
    2711             : #if !defined(AE_NO_EXCEPTIONS)
    2712           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2713             : #else
    2714             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2715             :         return;
    2716             : #endif
    2717             :     }
    2718           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2719           0 :     if( _xparams.flags!=0x0 )
    2720           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2721           0 :     alglib_impl::hpdmatrixcholeskysolvemfast(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_matrix*>(b.c_ptr()), m, &info, &_alglib_env_state);
    2722           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2723           0 :     return;
    2724             : }
    2725             : 
    2726             : /*************************************************************************
    2727             : Dense solver for A*x=b with N*N Hermitian positive definite matrix A given
    2728             : by its Cholesky decomposition, and N*1 complex vectors x and  b.  This  is
    2729             : "slow-but-feature-rich" version of the solver  which  estimates  condition
    2730             : number of the system.
    2731             : 
    2732             : Algorithm features:
    2733             : * automatic detection of degenerate cases
    2734             : * O(N^2) complexity
    2735             : * condition number estimation
    2736             : * matrix is represented by its upper or lower triangle
    2737             : 
    2738             : No iterative refinement is provided because such partial representation of
    2739             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    2740             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    2741             : need iterative refinement.
    2742             : 
    2743             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    2744             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    2745             :            ! which results in 10-15x  performance  penalty  when  compared
    2746             :            ! with "fast" version which just calls triangular solver.
    2747             :            !
    2748             :            ! This performance penalty is insignificant  when compared with
    2749             :            ! cost of large LU decomposition.  However,  if you  call  this
    2750             :            ! function many times for the same  left  side,  this  overhead
    2751             :            ! BECOMES significant. It  also  becomes significant for small-
    2752             :            ! scale problems (N<50).
    2753             :            !
    2754             :            ! In such cases we strongly recommend you to use faster solver,
    2755             :            ! HPDMatrixCholeskySolveFast() function.
    2756             : 
    2757             : INPUT PARAMETERS
    2758             :     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,
    2759             :                 SPDMatrixCholesky result
    2760             :     N       -   size of A
    2761             :     IsUpper -   what half of CHA is provided
    2762             :     B       -   array[0..N-1], right part
    2763             : 
    2764             : OUTPUT PARAMETERS
    2765             :     Info    -   return code:
    2766             :                 * -3    A is is exactly singular or ill conditioned
    2767             :                         X is filled by zeros in such cases.
    2768             :                 * -1    N<=0 was passed
    2769             :                 *  1    task is solved
    2770             :     Rep     -   additional report, following fields are set:
    2771             :                 * rep.r1    condition number in 1-norm
    2772             :                 * rep.rinf  condition number in inf-norm
    2773             :     X       -   array[N]:
    2774             :                 * for info>0  - solution
    2775             :                 * for info=-3 - filled by zeros
    2776             : 
    2777             :   -- ALGLIB --
    2778             :      Copyright 27.01.2010 by Bochkanov Sergey
    2779             : *************************************************************************/
    2780           0 : 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)
    2781             : {
    2782             :     jmp_buf _break_jump;
    2783             :     alglib_impl::ae_state _alglib_env_state;
    2784           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2785           0 :     if( setjmp(_break_jump) )
    2786             :     {
    2787             : #if !defined(AE_NO_EXCEPTIONS)
    2788           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2789             : #else
    2790             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2791             :         return;
    2792             : #endif
    2793             :     }
    2794           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2795           0 :     if( _xparams.flags!=0x0 )
    2796           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2797           0 :     alglib_impl::hpdmatrixcholeskysolve(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, const_cast<alglib_impl::densesolverreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    2798           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2799           0 :     return;
    2800             : }
    2801             : 
    2802             : /*************************************************************************
    2803             : Dense solver for A*x=b with N*N Hermitian positive definite matrix A given
    2804             : by its Cholesky decomposition, and N*1 complex vectors x and  b.  This  is
    2805             : "fast-but-lightweight" version of the solver.
    2806             : 
    2807             : Algorithm features:
    2808             : * O(N^2) complexity
    2809             : * matrix is represented by its upper or lower triangle
    2810             : * no additional time-consuming features
    2811             : 
    2812             : INPUT PARAMETERS
    2813             :     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,
    2814             :                 SPDMatrixCholesky result
    2815             :     N       -   size of A
    2816             :     IsUpper -   what half of CHA is provided
    2817             :     B       -   array[0..N-1], right part
    2818             : 
    2819             : OUTPUT PARAMETERS
    2820             :     Info    -   return code:
    2821             :                 * -3    A is is exactly singular or ill conditioned
    2822             :                         B is filled by zeros in such cases.
    2823             :                 * -1    N<=0 was passed
    2824             :                 *  1    task is solved
    2825             :     B       -   array[N]:
    2826             :                 * for info>0  - overwritten by solution
    2827             :                 * for info=-3 - filled by zeros
    2828             : 
    2829             :   -- ALGLIB --
    2830             :      Copyright 18.03.2015 by Bochkanov Sergey
    2831             : *************************************************************************/
    2832           0 : 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)
    2833             : {
    2834             :     jmp_buf _break_jump;
    2835             :     alglib_impl::ae_state _alglib_env_state;
    2836           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2837           0 :     if( setjmp(_break_jump) )
    2838             :     {
    2839             : #if !defined(AE_NO_EXCEPTIONS)
    2840           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2841             : #else
    2842             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2843             :         return;
    2844             : #endif
    2845             :     }
    2846           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2847           0 :     if( _xparams.flags!=0x0 )
    2848           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2849           0 :     alglib_impl::hpdmatrixcholeskysolvefast(const_cast<alglib_impl::ae_matrix*>(cha.c_ptr()), n, isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &info, &_alglib_env_state);
    2850           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2851           0 :     return;
    2852             : }
    2853             : 
    2854             : /*************************************************************************
    2855             : Dense solver.
    2856             : 
    2857             : This subroutine finds solution of the linear system A*X=B with non-square,
    2858             : possibly degenerate A.  System  is  solved in the least squares sense, and
    2859             : general least squares solution  X = X0 + CX*y  which  minimizes |A*X-B| is
    2860             : returned. If A is non-degenerate, solution in the usual sense is returned.
    2861             : 
    2862             : Algorithm features:
    2863             : * automatic detection (and correct handling!) of degenerate cases
    2864             : * iterative refinement
    2865             : * O(N^3) complexity
    2866             : 
    2867             :   ! COMMERCIAL EDITION OF ALGLIB:
    2868             :   !
    2869             :   ! Commercial Edition of ALGLIB includes following important improvements
    2870             :   ! of this function:
    2871             :   ! * high-performance native backend with same C# interface (C# version)
    2872             :   ! * multithreading support (C++ and C# versions)
    2873             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    2874             :   !   (C++ and C# versions, x86/x64 platform)
    2875             :   !
    2876             :   ! We recommend you to read 'Working with commercial version' section  of
    2877             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    2878             :   ! related features provided by commercial edition of ALGLIB.
    2879             : 
    2880             : INPUT PARAMETERS
    2881             :     A       -   array[0..NRows-1,0..NCols-1], system matrix
    2882             :     NRows   -   vertical size of A
    2883             :     NCols   -   horizontal size of A
    2884             :     B       -   array[0..NCols-1], right part
    2885             :     Threshold-  a number in [0,1]. Singular values  beyond  Threshold  are
    2886             :                 considered  zero.  Set  it to 0.0, if you don't understand
    2887             :                 what it means, so the solver will choose good value on its
    2888             :                 own.
    2889             : 
    2890             : OUTPUT PARAMETERS
    2891             :     Info    -   return code:
    2892             :                 * -4    SVD subroutine failed
    2893             :                 * -1    if NRows<=0 or NCols<=0 or Threshold<0 was passed
    2894             :                 *  1    if task is solved
    2895             :     Rep     -   solver report, see below for more info
    2896             :     X       -   array[0..N-1,0..M-1], it contains:
    2897             :                 * solution of A*X=B (even for singular A)
    2898             :                 * zeros, if SVD subroutine failed
    2899             : 
    2900             : SOLVER REPORT
    2901             : 
    2902             : Subroutine sets following fields of the Rep structure:
    2903             : * R2        reciprocal of condition number: 1/cond(A), 2-norm.
    2904             : * N         = NCols
    2905             : * K         dim(Null(A))
    2906             : * CX        array[0..N-1,0..K-1], kernel of A.
    2907             :             Columns of CX store such vectors that A*CX[i]=0.
    2908             : 
    2909             :   -- ALGLIB --
    2910             :      Copyright 24.08.2009 by Bochkanov Sergey
    2911             : *************************************************************************/
    2912           0 : 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)
    2913             : {
    2914             :     jmp_buf _break_jump;
    2915             :     alglib_impl::ae_state _alglib_env_state;
    2916           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    2917           0 :     if( setjmp(_break_jump) )
    2918             :     {
    2919             : #if !defined(AE_NO_EXCEPTIONS)
    2920           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    2921             : #else
    2922             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    2923             :         return;
    2924             : #endif
    2925             :     }
    2926           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    2927           0 :     if( _xparams.flags!=0x0 )
    2928           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    2929           0 :     alglib_impl::rmatrixsolvels(const_cast<alglib_impl::ae_matrix*>(a.c_ptr()), nrows, ncols, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), threshold, &info, const_cast<alglib_impl::densesolverlsreport*>(rep.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    2930           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    2931           0 :     return;
    2932             : }
    2933             : #endif
    2934             : 
    2935             : #if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
    2936             : /*************************************************************************
    2937             : This object stores state of the LinLSQR method.
    2938             : 
    2939             : You should use ALGLIB functions to work with this object.
    2940             : *************************************************************************/
    2941           0 : _linlsqrstate_owner::_linlsqrstate_owner()
    2942             : {
    2943             :     jmp_buf _break_jump;
    2944             :     alglib_impl::ae_state _state;
    2945             :     
    2946           0 :     alglib_impl::ae_state_init(&_state);
    2947           0 :     if( setjmp(_break_jump) )
    2948             :     {
    2949           0 :         if( p_struct!=NULL )
    2950             :         {
    2951           0 :             alglib_impl::_linlsqrstate_destroy(p_struct);
    2952           0 :             alglib_impl::ae_free(p_struct);
    2953             :         }
    2954           0 :         p_struct = NULL;
    2955             : #if !defined(AE_NO_EXCEPTIONS)
    2956           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    2957             : #else
    2958             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    2959             :         return;
    2960             : #endif
    2961             :     }
    2962           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    2963           0 :     p_struct = NULL;
    2964           0 :     p_struct = (alglib_impl::linlsqrstate*)alglib_impl::ae_malloc(sizeof(alglib_impl::linlsqrstate), &_state);
    2965           0 :     memset(p_struct, 0, sizeof(alglib_impl::linlsqrstate));
    2966           0 :     alglib_impl::_linlsqrstate_init(p_struct, &_state, ae_false);
    2967           0 :     ae_state_clear(&_state);
    2968           0 : }
    2969             : 
    2970           0 : _linlsqrstate_owner::_linlsqrstate_owner(const _linlsqrstate_owner &rhs)
    2971             : {
    2972             :     jmp_buf _break_jump;
    2973             :     alglib_impl::ae_state _state;
    2974             :     
    2975           0 :     alglib_impl::ae_state_init(&_state);
    2976           0 :     if( setjmp(_break_jump) )
    2977             :     {
    2978           0 :         if( p_struct!=NULL )
    2979             :         {
    2980           0 :             alglib_impl::_linlsqrstate_destroy(p_struct);
    2981           0 :             alglib_impl::ae_free(p_struct);
    2982             :         }
    2983           0 :         p_struct = NULL;
    2984             : #if !defined(AE_NO_EXCEPTIONS)
    2985           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    2986             : #else
    2987             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    2988             :         return;
    2989             : #endif
    2990             :     }
    2991           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    2992           0 :     p_struct = NULL;
    2993           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: linlsqrstate copy constructor failure (source is not initialized)", &_state);
    2994           0 :     p_struct = (alglib_impl::linlsqrstate*)alglib_impl::ae_malloc(sizeof(alglib_impl::linlsqrstate), &_state);
    2995           0 :     memset(p_struct, 0, sizeof(alglib_impl::linlsqrstate));
    2996           0 :     alglib_impl::_linlsqrstate_init_copy(p_struct, const_cast<alglib_impl::linlsqrstate*>(rhs.p_struct), &_state, ae_false);
    2997           0 :     ae_state_clear(&_state);
    2998           0 : }
    2999             : 
    3000           0 : _linlsqrstate_owner& _linlsqrstate_owner::operator=(const _linlsqrstate_owner &rhs)
    3001             : {
    3002           0 :     if( this==&rhs )
    3003           0 :         return *this;
    3004             :     jmp_buf _break_jump;
    3005             :     alglib_impl::ae_state _state;
    3006             :     
    3007           0 :     alglib_impl::ae_state_init(&_state);
    3008           0 :     if( setjmp(_break_jump) )
    3009             :     {
    3010             : #if !defined(AE_NO_EXCEPTIONS)
    3011           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3012             : #else
    3013             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3014             :         return *this;
    3015             : #endif
    3016             :     }
    3017           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3018           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: linlsqrstate assignment constructor failure (destination is not initialized)", &_state);
    3019           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: linlsqrstate assignment constructor failure (source is not initialized)", &_state);
    3020           0 :     alglib_impl::_linlsqrstate_destroy(p_struct);
    3021           0 :     memset(p_struct, 0, sizeof(alglib_impl::linlsqrstate));
    3022           0 :     alglib_impl::_linlsqrstate_init_copy(p_struct, const_cast<alglib_impl::linlsqrstate*>(rhs.p_struct), &_state, ae_false);
    3023           0 :     ae_state_clear(&_state);
    3024           0 :     return *this;
    3025             : }
    3026             : 
    3027           0 : _linlsqrstate_owner::~_linlsqrstate_owner()
    3028             : {
    3029           0 :     if( p_struct!=NULL )
    3030             :     {
    3031           0 :         alglib_impl::_linlsqrstate_destroy(p_struct);
    3032           0 :         ae_free(p_struct);
    3033             :     }
    3034           0 : }
    3035             : 
    3036           0 : alglib_impl::linlsqrstate* _linlsqrstate_owner::c_ptr()
    3037             : {
    3038           0 :     return p_struct;
    3039             : }
    3040             : 
    3041           0 : alglib_impl::linlsqrstate* _linlsqrstate_owner::c_ptr() const
    3042             : {
    3043           0 :     return const_cast<alglib_impl::linlsqrstate*>(p_struct);
    3044             : }
    3045           0 : linlsqrstate::linlsqrstate() : _linlsqrstate_owner() 
    3046             : {
    3047           0 : }
    3048             : 
    3049           0 : linlsqrstate::linlsqrstate(const linlsqrstate &rhs):_linlsqrstate_owner(rhs) 
    3050             : {
    3051           0 : }
    3052             : 
    3053           0 : linlsqrstate& linlsqrstate::operator=(const linlsqrstate &rhs)
    3054             : {
    3055           0 :     if( this==&rhs )
    3056           0 :         return *this;
    3057           0 :     _linlsqrstate_owner::operator=(rhs);
    3058           0 :     return *this;
    3059             : }
    3060             : 
    3061           0 : linlsqrstate::~linlsqrstate()
    3062             : {
    3063           0 : }
    3064             : 
    3065             : 
    3066             : /*************************************************************************
    3067             : 
    3068             : *************************************************************************/
    3069           0 : _linlsqrreport_owner::_linlsqrreport_owner()
    3070             : {
    3071             :     jmp_buf _break_jump;
    3072             :     alglib_impl::ae_state _state;
    3073             :     
    3074           0 :     alglib_impl::ae_state_init(&_state);
    3075           0 :     if( setjmp(_break_jump) )
    3076             :     {
    3077           0 :         if( p_struct!=NULL )
    3078             :         {
    3079           0 :             alglib_impl::_linlsqrreport_destroy(p_struct);
    3080           0 :             alglib_impl::ae_free(p_struct);
    3081             :         }
    3082           0 :         p_struct = NULL;
    3083             : #if !defined(AE_NO_EXCEPTIONS)
    3084           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3085             : #else
    3086             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3087             :         return;
    3088             : #endif
    3089             :     }
    3090           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3091           0 :     p_struct = NULL;
    3092           0 :     p_struct = (alglib_impl::linlsqrreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::linlsqrreport), &_state);
    3093           0 :     memset(p_struct, 0, sizeof(alglib_impl::linlsqrreport));
    3094           0 :     alglib_impl::_linlsqrreport_init(p_struct, &_state, ae_false);
    3095           0 :     ae_state_clear(&_state);
    3096           0 : }
    3097             : 
    3098           0 : _linlsqrreport_owner::_linlsqrreport_owner(const _linlsqrreport_owner &rhs)
    3099             : {
    3100             :     jmp_buf _break_jump;
    3101             :     alglib_impl::ae_state _state;
    3102             :     
    3103           0 :     alglib_impl::ae_state_init(&_state);
    3104           0 :     if( setjmp(_break_jump) )
    3105             :     {
    3106           0 :         if( p_struct!=NULL )
    3107             :         {
    3108           0 :             alglib_impl::_linlsqrreport_destroy(p_struct);
    3109           0 :             alglib_impl::ae_free(p_struct);
    3110             :         }
    3111           0 :         p_struct = NULL;
    3112             : #if !defined(AE_NO_EXCEPTIONS)
    3113           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3114             : #else
    3115             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3116             :         return;
    3117             : #endif
    3118             :     }
    3119           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3120           0 :     p_struct = NULL;
    3121           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: linlsqrreport copy constructor failure (source is not initialized)", &_state);
    3122           0 :     p_struct = (alglib_impl::linlsqrreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::linlsqrreport), &_state);
    3123           0 :     memset(p_struct, 0, sizeof(alglib_impl::linlsqrreport));
    3124           0 :     alglib_impl::_linlsqrreport_init_copy(p_struct, const_cast<alglib_impl::linlsqrreport*>(rhs.p_struct), &_state, ae_false);
    3125           0 :     ae_state_clear(&_state);
    3126           0 : }
    3127             : 
    3128           0 : _linlsqrreport_owner& _linlsqrreport_owner::operator=(const _linlsqrreport_owner &rhs)
    3129             : {
    3130           0 :     if( this==&rhs )
    3131           0 :         return *this;
    3132             :     jmp_buf _break_jump;
    3133             :     alglib_impl::ae_state _state;
    3134             :     
    3135           0 :     alglib_impl::ae_state_init(&_state);
    3136           0 :     if( setjmp(_break_jump) )
    3137             :     {
    3138             : #if !defined(AE_NO_EXCEPTIONS)
    3139           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3140             : #else
    3141             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3142             :         return *this;
    3143             : #endif
    3144             :     }
    3145           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3146           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: linlsqrreport assignment constructor failure (destination is not initialized)", &_state);
    3147           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: linlsqrreport assignment constructor failure (source is not initialized)", &_state);
    3148           0 :     alglib_impl::_linlsqrreport_destroy(p_struct);
    3149           0 :     memset(p_struct, 0, sizeof(alglib_impl::linlsqrreport));
    3150           0 :     alglib_impl::_linlsqrreport_init_copy(p_struct, const_cast<alglib_impl::linlsqrreport*>(rhs.p_struct), &_state, ae_false);
    3151           0 :     ae_state_clear(&_state);
    3152           0 :     return *this;
    3153             : }
    3154             : 
    3155           0 : _linlsqrreport_owner::~_linlsqrreport_owner()
    3156             : {
    3157           0 :     if( p_struct!=NULL )
    3158             :     {
    3159           0 :         alglib_impl::_linlsqrreport_destroy(p_struct);
    3160           0 :         ae_free(p_struct);
    3161             :     }
    3162           0 : }
    3163             : 
    3164           0 : alglib_impl::linlsqrreport* _linlsqrreport_owner::c_ptr()
    3165             : {
    3166           0 :     return p_struct;
    3167             : }
    3168             : 
    3169           0 : alglib_impl::linlsqrreport* _linlsqrreport_owner::c_ptr() const
    3170             : {
    3171           0 :     return const_cast<alglib_impl::linlsqrreport*>(p_struct);
    3172             : }
    3173           0 : linlsqrreport::linlsqrreport() : _linlsqrreport_owner() ,iterationscount(p_struct->iterationscount),nmv(p_struct->nmv),terminationtype(p_struct->terminationtype)
    3174             : {
    3175           0 : }
    3176             : 
    3177           0 : linlsqrreport::linlsqrreport(const linlsqrreport &rhs):_linlsqrreport_owner(rhs) ,iterationscount(p_struct->iterationscount),nmv(p_struct->nmv),terminationtype(p_struct->terminationtype)
    3178             : {
    3179           0 : }
    3180             : 
    3181           0 : linlsqrreport& linlsqrreport::operator=(const linlsqrreport &rhs)
    3182             : {
    3183           0 :     if( this==&rhs )
    3184           0 :         return *this;
    3185           0 :     _linlsqrreport_owner::operator=(rhs);
    3186           0 :     return *this;
    3187             : }
    3188             : 
    3189           0 : linlsqrreport::~linlsqrreport()
    3190             : {
    3191           0 : }
    3192             : 
    3193             : /*************************************************************************
    3194             : This function initializes linear LSQR Solver. This solver is used to solve
    3195             : non-symmetric (and, possibly, non-square) problems. Least squares solution
    3196             : is returned for non-compatible systems.
    3197             : 
    3198             : USAGE:
    3199             : 1. User initializes algorithm state with LinLSQRCreate() call
    3200             : 2. User tunes solver parameters with  LinLSQRSetCond() and other functions
    3201             : 3. User  calls  LinLSQRSolveSparse()  function which takes algorithm state
    3202             :    and SparseMatrix object.
    3203             : 4. User calls LinLSQRResults() to get solution
    3204             : 5. Optionally, user may call LinLSQRSolveSparse() again to  solve  another
    3205             :    problem  with different matrix and/or right part without reinitializing
    3206             :    LinLSQRState structure.
    3207             : 
    3208             : INPUT PARAMETERS:
    3209             :     M       -   number of rows in A
    3210             :     N       -   number of variables, N>0
    3211             : 
    3212             : OUTPUT PARAMETERS:
    3213             :     State   -   structure which stores algorithm state
    3214             : 
    3215             : NOTE: see also linlsqrcreatebuf()  for  version  which  reuses  previously
    3216             :       allocated place as much as possible.
    3217             : 
    3218             :   -- ALGLIB --
    3219             :      Copyright 30.11.2011 by Bochkanov Sergey
    3220             : *************************************************************************/
    3221           0 : void linlsqrcreate(const ae_int_t m, const ae_int_t n, linlsqrstate &state, const xparams _xparams)
    3222             : {
    3223             :     jmp_buf _break_jump;
    3224             :     alglib_impl::ae_state _alglib_env_state;
    3225           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3226           0 :     if( setjmp(_break_jump) )
    3227             :     {
    3228             : #if !defined(AE_NO_EXCEPTIONS)
    3229           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3230             : #else
    3231             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3232             :         return;
    3233             : #endif
    3234             :     }
    3235           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3236           0 :     if( _xparams.flags!=0x0 )
    3237           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3238           0 :     alglib_impl::linlsqrcreate(m, n, const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), &_alglib_env_state);
    3239           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3240           0 :     return;
    3241             : }
    3242             : 
    3243             : /*************************************************************************
    3244             : This function initializes linear LSQR Solver.  It  provides  exactly  same
    3245             : functionality as linlsqrcreate(), but reuses  previously  allocated  space
    3246             : as much as possible.
    3247             : 
    3248             : INPUT PARAMETERS:
    3249             :     M       -   number of rows in A
    3250             :     N       -   number of variables, N>0
    3251             : 
    3252             : OUTPUT PARAMETERS:
    3253             :     State   -   structure which stores algorithm state
    3254             : 
    3255             :   -- ALGLIB --
    3256             :      Copyright 14.11.2018 by Bochkanov Sergey
    3257             : *************************************************************************/
    3258           0 : void linlsqrcreatebuf(const ae_int_t m, const ae_int_t n, const linlsqrstate &state, const xparams _xparams)
    3259             : {
    3260             :     jmp_buf _break_jump;
    3261             :     alglib_impl::ae_state _alglib_env_state;
    3262           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3263           0 :     if( setjmp(_break_jump) )
    3264             :     {
    3265             : #if !defined(AE_NO_EXCEPTIONS)
    3266           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3267             : #else
    3268             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3269             :         return;
    3270             : #endif
    3271             :     }
    3272           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3273           0 :     if( _xparams.flags!=0x0 )
    3274           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3275           0 :     alglib_impl::linlsqrcreatebuf(m, n, const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), &_alglib_env_state);
    3276           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3277           0 :     return;
    3278             : }
    3279             : 
    3280             : /*************************************************************************
    3281             : This  function  changes  preconditioning  settings of LinLSQQSolveSparse()
    3282             : function. By default, SolveSparse() uses diagonal preconditioner,  but  if
    3283             : you want to use solver without preconditioning, you can call this function
    3284             : which forces solver to use unit matrix for preconditioning.
    3285             : 
    3286             : INPUT PARAMETERS:
    3287             :     State   -   structure which stores algorithm state
    3288             : 
    3289             :   -- ALGLIB --
    3290             :      Copyright 19.11.2012 by Bochkanov Sergey
    3291             : *************************************************************************/
    3292           0 : void linlsqrsetprecunit(const linlsqrstate &state, const xparams _xparams)
    3293             : {
    3294             :     jmp_buf _break_jump;
    3295             :     alglib_impl::ae_state _alglib_env_state;
    3296           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3297           0 :     if( setjmp(_break_jump) )
    3298             :     {
    3299             : #if !defined(AE_NO_EXCEPTIONS)
    3300           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3301             : #else
    3302             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3303             :         return;
    3304             : #endif
    3305             :     }
    3306           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3307           0 :     if( _xparams.flags!=0x0 )
    3308           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3309           0 :     alglib_impl::linlsqrsetprecunit(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), &_alglib_env_state);
    3310           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3311           0 :     return;
    3312             : }
    3313             : 
    3314             : /*************************************************************************
    3315             : This  function  changes  preconditioning  settings  of  LinCGSolveSparse()
    3316             : function.  LinCGSolveSparse() will use diagonal of the  system  matrix  as
    3317             : preconditioner. This preconditioning mode is active by default.
    3318             : 
    3319             : INPUT PARAMETERS:
    3320             :     State   -   structure which stores algorithm state
    3321             : 
    3322             :   -- ALGLIB --
    3323             :      Copyright 19.11.2012 by Bochkanov Sergey
    3324             : *************************************************************************/
    3325           0 : void linlsqrsetprecdiag(const linlsqrstate &state, const xparams _xparams)
    3326             : {
    3327             :     jmp_buf _break_jump;
    3328             :     alglib_impl::ae_state _alglib_env_state;
    3329           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3330           0 :     if( setjmp(_break_jump) )
    3331             :     {
    3332             : #if !defined(AE_NO_EXCEPTIONS)
    3333           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3334             : #else
    3335             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3336             :         return;
    3337             : #endif
    3338             :     }
    3339           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3340           0 :     if( _xparams.flags!=0x0 )
    3341           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3342           0 :     alglib_impl::linlsqrsetprecdiag(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), &_alglib_env_state);
    3343           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3344           0 :     return;
    3345             : }
    3346             : 
    3347             : /*************************************************************************
    3348             : This function sets optional Tikhonov regularization coefficient.
    3349             : It is zero by default.
    3350             : 
    3351             : INPUT PARAMETERS:
    3352             :     LambdaI -   regularization factor, LambdaI>=0
    3353             : 
    3354             : OUTPUT PARAMETERS:
    3355             :     State   -   structure which stores algorithm state
    3356             : 
    3357             :   -- ALGLIB --
    3358             :      Copyright 30.11.2011 by Bochkanov Sergey
    3359             : *************************************************************************/
    3360           0 : void linlsqrsetlambdai(const linlsqrstate &state, const double lambdai, const xparams _xparams)
    3361             : {
    3362             :     jmp_buf _break_jump;
    3363             :     alglib_impl::ae_state _alglib_env_state;
    3364           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3365           0 :     if( setjmp(_break_jump) )
    3366             :     {
    3367             : #if !defined(AE_NO_EXCEPTIONS)
    3368           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3369             : #else
    3370             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3371             :         return;
    3372             : #endif
    3373             :     }
    3374           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3375           0 :     if( _xparams.flags!=0x0 )
    3376           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3377           0 :     alglib_impl::linlsqrsetlambdai(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), lambdai, &_alglib_env_state);
    3378           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3379           0 :     return;
    3380             : }
    3381             : 
    3382             : /*************************************************************************
    3383             : Procedure for solution of A*x=b with sparse A.
    3384             : 
    3385             : INPUT PARAMETERS:
    3386             :     State   -   algorithm state
    3387             :     A       -   sparse M*N matrix in the CRS format (you MUST contvert  it
    3388             :                 to CRS format  by  calling  SparseConvertToCRS()  function
    3389             :                 BEFORE you pass it to this function).
    3390             :     B       -   right part, array[M]
    3391             : 
    3392             : RESULT:
    3393             :     This function returns no result.
    3394             :     You can get solution by calling LinCGResults()
    3395             : 
    3396             : NOTE: this function uses lightweight preconditioning -  multiplication  by
    3397             :       inverse of diag(A). If you want, you can turn preconditioning off by
    3398             :       calling LinLSQRSetPrecUnit(). However, preconditioning cost is   low
    3399             :       and preconditioner is very important for solution  of  badly  scaled
    3400             :       problems.
    3401             : 
    3402             :   -- ALGLIB --
    3403             :      Copyright 30.11.2011 by Bochkanov Sergey
    3404             : *************************************************************************/
    3405           0 : void linlsqrsolvesparse(const linlsqrstate &state, const sparsematrix &a, const real_1d_array &b, const xparams _xparams)
    3406             : {
    3407             :     jmp_buf _break_jump;
    3408             :     alglib_impl::ae_state _alglib_env_state;
    3409           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3410           0 :     if( setjmp(_break_jump) )
    3411             :     {
    3412             : #if !defined(AE_NO_EXCEPTIONS)
    3413           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3414             : #else
    3415             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3416             :         return;
    3417             : #endif
    3418             :     }
    3419           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3420           0 :     if( _xparams.flags!=0x0 )
    3421           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3422           0 :     alglib_impl::linlsqrsolvesparse(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), const_cast<alglib_impl::sparsematrix*>(a.c_ptr()), const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &_alglib_env_state);
    3423           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3424           0 :     return;
    3425             : }
    3426             : 
    3427             : /*************************************************************************
    3428             : This function sets stopping criteria.
    3429             : 
    3430             : INPUT PARAMETERS:
    3431             :     EpsA    -   algorithm will be stopped if ||A^T*Rk||/(||A||*||Rk||)<=EpsA.
    3432             :     EpsB    -   algorithm will be stopped if ||Rk||<=EpsB*||B||
    3433             :     MaxIts  -   algorithm will be stopped if number of iterations
    3434             :                 more than MaxIts.
    3435             : 
    3436             : OUTPUT PARAMETERS:
    3437             :     State   -   structure which stores algorithm state
    3438             : 
    3439             : NOTE: if EpsA,EpsB,EpsC and MaxIts are zero then these variables will
    3440             : be setted as default values.
    3441             : 
    3442             :   -- ALGLIB --
    3443             :      Copyright 30.11.2011 by Bochkanov Sergey
    3444             : *************************************************************************/
    3445           0 : void linlsqrsetcond(const linlsqrstate &state, const double epsa, const double epsb, const ae_int_t maxits, const xparams _xparams)
    3446             : {
    3447             :     jmp_buf _break_jump;
    3448             :     alglib_impl::ae_state _alglib_env_state;
    3449           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3450           0 :     if( setjmp(_break_jump) )
    3451             :     {
    3452             : #if !defined(AE_NO_EXCEPTIONS)
    3453           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3454             : #else
    3455             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3456             :         return;
    3457             : #endif
    3458             :     }
    3459           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3460           0 :     if( _xparams.flags!=0x0 )
    3461           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3462           0 :     alglib_impl::linlsqrsetcond(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), epsa, epsb, maxits, &_alglib_env_state);
    3463           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3464           0 :     return;
    3465             : }
    3466             : 
    3467             : /*************************************************************************
    3468             : LSQR solver: results.
    3469             : 
    3470             : This function must be called after LinLSQRSolve
    3471             : 
    3472             : INPUT PARAMETERS:
    3473             :     State   -   algorithm state
    3474             : 
    3475             : OUTPUT PARAMETERS:
    3476             :     X       -   array[N], solution
    3477             :     Rep     -   optimization report:
    3478             :                 * Rep.TerminationType completetion code:
    3479             :                     *  1    ||Rk||<=EpsB*||B||
    3480             :                     *  4    ||A^T*Rk||/(||A||*||Rk||)<=EpsA
    3481             :                     *  5    MaxIts steps was taken
    3482             :                     *  7    rounding errors prevent further progress,
    3483             :                             X contains best point found so far.
    3484             :                             (sometimes returned on singular systems)
    3485             :                     *  8    user requested termination via calling
    3486             :                             linlsqrrequesttermination()
    3487             :                 * Rep.IterationsCount contains iterations count
    3488             :                 * NMV countains number of matrix-vector calculations
    3489             : 
    3490             :   -- ALGLIB --
    3491             :      Copyright 30.11.2011 by Bochkanov Sergey
    3492             : *************************************************************************/
    3493           0 : void linlsqrresults(const linlsqrstate &state, real_1d_array &x, linlsqrreport &rep, const xparams _xparams)
    3494             : {
    3495             :     jmp_buf _break_jump;
    3496             :     alglib_impl::ae_state _alglib_env_state;
    3497           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3498           0 :     if( setjmp(_break_jump) )
    3499             :     {
    3500             : #if !defined(AE_NO_EXCEPTIONS)
    3501           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3502             : #else
    3503             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3504             :         return;
    3505             : #endif
    3506             :     }
    3507           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3508           0 :     if( _xparams.flags!=0x0 )
    3509           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3510           0 :     alglib_impl::linlsqrresults(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::linlsqrreport*>(rep.c_ptr()), &_alglib_env_state);
    3511           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3512           0 :     return;
    3513             : }
    3514             : 
    3515             : /*************************************************************************
    3516             : This function turns on/off reporting.
    3517             : 
    3518             : INPUT PARAMETERS:
    3519             :     State   -   structure which stores algorithm state
    3520             :     NeedXRep-   whether iteration reports are needed or not
    3521             : 
    3522             : If NeedXRep is True, algorithm will call rep() callback function if  it is
    3523             : provided to MinCGOptimize().
    3524             : 
    3525             :   -- ALGLIB --
    3526             :      Copyright 30.11.2011 by Bochkanov Sergey
    3527             : *************************************************************************/
    3528           0 : void linlsqrsetxrep(const linlsqrstate &state, const bool needxrep, const xparams _xparams)
    3529             : {
    3530             :     jmp_buf _break_jump;
    3531             :     alglib_impl::ae_state _alglib_env_state;
    3532           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3533           0 :     if( setjmp(_break_jump) )
    3534             :     {
    3535             : #if !defined(AE_NO_EXCEPTIONS)
    3536           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3537             : #else
    3538             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3539             :         return;
    3540             : #endif
    3541             :     }
    3542           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3543           0 :     if( _xparams.flags!=0x0 )
    3544           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3545           0 :     alglib_impl::linlsqrsetxrep(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), needxrep, &_alglib_env_state);
    3546           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3547           0 :     return;
    3548             : }
    3549             : 
    3550             : /*************************************************************************
    3551             : This function is used to peek into LSQR solver and get  current  iteration
    3552             : counter. You can safely "peek" into the solver from another thread.
    3553             : 
    3554             : INPUT PARAMETERS:
    3555             :     S           -   solver object
    3556             : 
    3557             : RESULT:
    3558             :     iteration counter, in [0,INF)
    3559             : 
    3560             :   -- ALGLIB --
    3561             :      Copyright 21.05.2018 by Bochkanov Sergey
    3562             : *************************************************************************/
    3563           0 : ae_int_t linlsqrpeekiterationscount(const linlsqrstate &s, const xparams _xparams)
    3564             : {
    3565             :     jmp_buf _break_jump;
    3566             :     alglib_impl::ae_state _alglib_env_state;
    3567           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3568           0 :     if( setjmp(_break_jump) )
    3569             :     {
    3570             : #if !defined(AE_NO_EXCEPTIONS)
    3571           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3572             : #else
    3573             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3574             :         return 0;
    3575             : #endif
    3576             :     }
    3577           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3578           0 :     if( _xparams.flags!=0x0 )
    3579           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3580           0 :     alglib_impl::ae_int_t result = alglib_impl::linlsqrpeekiterationscount(const_cast<alglib_impl::linlsqrstate*>(s.c_ptr()), &_alglib_env_state);
    3581           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3582           0 :     return *(reinterpret_cast<ae_int_t*>(&result));
    3583             : }
    3584             : 
    3585             : /*************************************************************************
    3586             : This subroutine submits request for termination of the running solver.  It
    3587             : can be called from some other thread which wants LSQR solver to  terminate
    3588             : (obviously, the  thread  running  LSQR  solver can not request termination
    3589             : because it is already busy working on LSQR).
    3590             : 
    3591             : As result, solver  stops  at  point  which  was  "current  accepted"  when
    3592             : termination  request  was  submitted  and returns error code 8 (successful
    3593             : termination).  Such   termination   is  a smooth  process  which  properly
    3594             : deallocates all temporaries.
    3595             : 
    3596             : INPUT PARAMETERS:
    3597             :     State   -   solver structure
    3598             : 
    3599             : NOTE: calling this function on solver which is NOT running  will  have  no
    3600             :       effect.
    3601             : 
    3602             : NOTE: multiple calls to this function are possible. First call is counted,
    3603             :       subsequent calls are silently ignored.
    3604             : 
    3605             : NOTE: solver clears termination flag on its start, it means that  if  some
    3606             :       other thread will request termination too soon, its request will went
    3607             :       unnoticed.
    3608             : 
    3609             :   -- ALGLIB --
    3610             :      Copyright 08.10.2014 by Bochkanov Sergey
    3611             : *************************************************************************/
    3612           0 : void linlsqrrequesttermination(const linlsqrstate &state, const xparams _xparams)
    3613             : {
    3614             :     jmp_buf _break_jump;
    3615             :     alglib_impl::ae_state _alglib_env_state;
    3616           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3617           0 :     if( setjmp(_break_jump) )
    3618             :     {
    3619             : #if !defined(AE_NO_EXCEPTIONS)
    3620           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3621             : #else
    3622             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3623             :         return;
    3624             : #endif
    3625             :     }
    3626           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3627           0 :     if( _xparams.flags!=0x0 )
    3628           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3629           0 :     alglib_impl::linlsqrrequesttermination(const_cast<alglib_impl::linlsqrstate*>(state.c_ptr()), &_alglib_env_state);
    3630           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3631           0 :     return;
    3632             : }
    3633             : #endif
    3634             : 
    3635             : #if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
    3636             : /*************************************************************************
    3637             : 
    3638             : *************************************************************************/
    3639           0 : _polynomialsolverreport_owner::_polynomialsolverreport_owner()
    3640             : {
    3641             :     jmp_buf _break_jump;
    3642             :     alglib_impl::ae_state _state;
    3643             :     
    3644           0 :     alglib_impl::ae_state_init(&_state);
    3645           0 :     if( setjmp(_break_jump) )
    3646             :     {
    3647           0 :         if( p_struct!=NULL )
    3648             :         {
    3649           0 :             alglib_impl::_polynomialsolverreport_destroy(p_struct);
    3650           0 :             alglib_impl::ae_free(p_struct);
    3651             :         }
    3652           0 :         p_struct = NULL;
    3653             : #if !defined(AE_NO_EXCEPTIONS)
    3654           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3655             : #else
    3656             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3657             :         return;
    3658             : #endif
    3659             :     }
    3660           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3661           0 :     p_struct = NULL;
    3662           0 :     p_struct = (alglib_impl::polynomialsolverreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::polynomialsolverreport), &_state);
    3663           0 :     memset(p_struct, 0, sizeof(alglib_impl::polynomialsolverreport));
    3664           0 :     alglib_impl::_polynomialsolverreport_init(p_struct, &_state, ae_false);
    3665           0 :     ae_state_clear(&_state);
    3666           0 : }
    3667             : 
    3668           0 : _polynomialsolverreport_owner::_polynomialsolverreport_owner(const _polynomialsolverreport_owner &rhs)
    3669             : {
    3670             :     jmp_buf _break_jump;
    3671             :     alglib_impl::ae_state _state;
    3672             :     
    3673           0 :     alglib_impl::ae_state_init(&_state);
    3674           0 :     if( setjmp(_break_jump) )
    3675             :     {
    3676           0 :         if( p_struct!=NULL )
    3677             :         {
    3678           0 :             alglib_impl::_polynomialsolverreport_destroy(p_struct);
    3679           0 :             alglib_impl::ae_free(p_struct);
    3680             :         }
    3681           0 :         p_struct = NULL;
    3682             : #if !defined(AE_NO_EXCEPTIONS)
    3683           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3684             : #else
    3685             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3686             :         return;
    3687             : #endif
    3688             :     }
    3689           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3690           0 :     p_struct = NULL;
    3691           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: polynomialsolverreport copy constructor failure (source is not initialized)", &_state);
    3692           0 :     p_struct = (alglib_impl::polynomialsolverreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::polynomialsolverreport), &_state);
    3693           0 :     memset(p_struct, 0, sizeof(alglib_impl::polynomialsolverreport));
    3694           0 :     alglib_impl::_polynomialsolverreport_init_copy(p_struct, const_cast<alglib_impl::polynomialsolverreport*>(rhs.p_struct), &_state, ae_false);
    3695           0 :     ae_state_clear(&_state);
    3696           0 : }
    3697             : 
    3698           0 : _polynomialsolverreport_owner& _polynomialsolverreport_owner::operator=(const _polynomialsolverreport_owner &rhs)
    3699             : {
    3700           0 :     if( this==&rhs )
    3701           0 :         return *this;
    3702             :     jmp_buf _break_jump;
    3703             :     alglib_impl::ae_state _state;
    3704             :     
    3705           0 :     alglib_impl::ae_state_init(&_state);
    3706           0 :     if( setjmp(_break_jump) )
    3707             :     {
    3708             : #if !defined(AE_NO_EXCEPTIONS)
    3709           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3710             : #else
    3711             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3712             :         return *this;
    3713             : #endif
    3714             :     }
    3715           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3716           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: polynomialsolverreport assignment constructor failure (destination is not initialized)", &_state);
    3717           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: polynomialsolverreport assignment constructor failure (source is not initialized)", &_state);
    3718           0 :     alglib_impl::_polynomialsolverreport_destroy(p_struct);
    3719           0 :     memset(p_struct, 0, sizeof(alglib_impl::polynomialsolverreport));
    3720           0 :     alglib_impl::_polynomialsolverreport_init_copy(p_struct, const_cast<alglib_impl::polynomialsolverreport*>(rhs.p_struct), &_state, ae_false);
    3721           0 :     ae_state_clear(&_state);
    3722           0 :     return *this;
    3723             : }
    3724             : 
    3725           0 : _polynomialsolverreport_owner::~_polynomialsolverreport_owner()
    3726             : {
    3727           0 :     if( p_struct!=NULL )
    3728             :     {
    3729           0 :         alglib_impl::_polynomialsolverreport_destroy(p_struct);
    3730           0 :         ae_free(p_struct);
    3731             :     }
    3732           0 : }
    3733             : 
    3734           0 : alglib_impl::polynomialsolverreport* _polynomialsolverreport_owner::c_ptr()
    3735             : {
    3736           0 :     return p_struct;
    3737             : }
    3738             : 
    3739           0 : alglib_impl::polynomialsolverreport* _polynomialsolverreport_owner::c_ptr() const
    3740             : {
    3741           0 :     return const_cast<alglib_impl::polynomialsolverreport*>(p_struct);
    3742             : }
    3743           0 : polynomialsolverreport::polynomialsolverreport() : _polynomialsolverreport_owner() ,maxerr(p_struct->maxerr)
    3744             : {
    3745           0 : }
    3746             : 
    3747           0 : polynomialsolverreport::polynomialsolverreport(const polynomialsolverreport &rhs):_polynomialsolverreport_owner(rhs) ,maxerr(p_struct->maxerr)
    3748             : {
    3749           0 : }
    3750             : 
    3751           0 : polynomialsolverreport& polynomialsolverreport::operator=(const polynomialsolverreport &rhs)
    3752             : {
    3753           0 :     if( this==&rhs )
    3754           0 :         return *this;
    3755           0 :     _polynomialsolverreport_owner::operator=(rhs);
    3756           0 :     return *this;
    3757             : }
    3758             : 
    3759           0 : polynomialsolverreport::~polynomialsolverreport()
    3760             : {
    3761           0 : }
    3762             : 
    3763             : /*************************************************************************
    3764             : Polynomial root finding.
    3765             : 
    3766             : This function returns all roots of the polynomial
    3767             :     P(x) = a0 + a1*x + a2*x^2 + ... + an*x^n
    3768             : Both real and complex roots are returned (see below).
    3769             : 
    3770             : INPUT PARAMETERS:
    3771             :     A       -   array[N+1], polynomial coefficients:
    3772             :                 * A[0] is constant term
    3773             :                 * A[N] is a coefficient of X^N
    3774             :     N       -   polynomial degree
    3775             : 
    3776             : OUTPUT PARAMETERS:
    3777             :     X       -   array of complex roots:
    3778             :                 * for isolated real root, X[I] is strictly real: IMAGE(X[I])=0
    3779             :                 * complex roots are always returned in pairs - roots occupy
    3780             :                   positions I and I+1, with:
    3781             :                   * X[I+1]=Conj(X[I])
    3782             :                   * IMAGE(X[I]) > 0
    3783             :                   * IMAGE(X[I+1]) = -IMAGE(X[I]) < 0
    3784             :                 * multiple real roots may have non-zero imaginary part due
    3785             :                   to roundoff errors. There is no reliable way to distinguish
    3786             :                   real root of multiplicity 2 from two  complex  roots  in
    3787             :                   the presence of roundoff errors.
    3788             :     Rep     -   report, additional information, following fields are set:
    3789             :                 * Rep.MaxErr - max( |P(xi)| )  for  i=0..N-1.  This  field
    3790             :                   allows to quickly estimate "quality" of the roots  being
    3791             :                   returned.
    3792             : 
    3793             : NOTE:   this function uses companion matrix method to find roots. In  case
    3794             :         internal EVD  solver  fails  do  find  eigenvalues,  exception  is
    3795             :         generated.
    3796             : 
    3797             : NOTE:   roots are not "polished" and  no  matrix  balancing  is  performed
    3798             :         for them.
    3799             : 
    3800             :   -- ALGLIB --
    3801             :      Copyright 24.02.2014 by Bochkanov Sergey
    3802             : *************************************************************************/
    3803           0 : void polynomialsolve(const real_1d_array &a, const ae_int_t n, complex_1d_array &x, polynomialsolverreport &rep, const xparams _xparams)
    3804             : {
    3805             :     jmp_buf _break_jump;
    3806             :     alglib_impl::ae_state _alglib_env_state;
    3807           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    3808           0 :     if( setjmp(_break_jump) )
    3809             :     {
    3810             : #if !defined(AE_NO_EXCEPTIONS)
    3811           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    3812             : #else
    3813             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    3814             :         return;
    3815             : #endif
    3816             :     }
    3817           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    3818           0 :     if( _xparams.flags!=0x0 )
    3819           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    3820           0 :     alglib_impl::polynomialsolve(const_cast<alglib_impl::ae_vector*>(a.c_ptr()), n, const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::polynomialsolverreport*>(rep.c_ptr()), &_alglib_env_state);
    3821           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    3822           0 :     return;
    3823             : }
    3824             : #endif
    3825             : 
    3826             : #if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
    3827             : /*************************************************************************
    3828             : 
    3829             : *************************************************************************/
    3830           0 : _nleqstate_owner::_nleqstate_owner()
    3831             : {
    3832             :     jmp_buf _break_jump;
    3833             :     alglib_impl::ae_state _state;
    3834             :     
    3835           0 :     alglib_impl::ae_state_init(&_state);
    3836           0 :     if( setjmp(_break_jump) )
    3837             :     {
    3838           0 :         if( p_struct!=NULL )
    3839             :         {
    3840           0 :             alglib_impl::_nleqstate_destroy(p_struct);
    3841           0 :             alglib_impl::ae_free(p_struct);
    3842             :         }
    3843           0 :         p_struct = NULL;
    3844             : #if !defined(AE_NO_EXCEPTIONS)
    3845           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3846             : #else
    3847             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3848             :         return;
    3849             : #endif
    3850             :     }
    3851           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3852           0 :     p_struct = NULL;
    3853           0 :     p_struct = (alglib_impl::nleqstate*)alglib_impl::ae_malloc(sizeof(alglib_impl::nleqstate), &_state);
    3854           0 :     memset(p_struct, 0, sizeof(alglib_impl::nleqstate));
    3855           0 :     alglib_impl::_nleqstate_init(p_struct, &_state, ae_false);
    3856           0 :     ae_state_clear(&_state);
    3857           0 : }
    3858             : 
    3859           0 : _nleqstate_owner::_nleqstate_owner(const _nleqstate_owner &rhs)
    3860             : {
    3861             :     jmp_buf _break_jump;
    3862             :     alglib_impl::ae_state _state;
    3863             :     
    3864           0 :     alglib_impl::ae_state_init(&_state);
    3865           0 :     if( setjmp(_break_jump) )
    3866             :     {
    3867           0 :         if( p_struct!=NULL )
    3868             :         {
    3869           0 :             alglib_impl::_nleqstate_destroy(p_struct);
    3870           0 :             alglib_impl::ae_free(p_struct);
    3871             :         }
    3872           0 :         p_struct = NULL;
    3873             : #if !defined(AE_NO_EXCEPTIONS)
    3874           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3875             : #else
    3876             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3877             :         return;
    3878             : #endif
    3879             :     }
    3880           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3881           0 :     p_struct = NULL;
    3882           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: nleqstate copy constructor failure (source is not initialized)", &_state);
    3883           0 :     p_struct = (alglib_impl::nleqstate*)alglib_impl::ae_malloc(sizeof(alglib_impl::nleqstate), &_state);
    3884           0 :     memset(p_struct, 0, sizeof(alglib_impl::nleqstate));
    3885           0 :     alglib_impl::_nleqstate_init_copy(p_struct, const_cast<alglib_impl::nleqstate*>(rhs.p_struct), &_state, ae_false);
    3886           0 :     ae_state_clear(&_state);
    3887           0 : }
    3888             : 
    3889           0 : _nleqstate_owner& _nleqstate_owner::operator=(const _nleqstate_owner &rhs)
    3890             : {
    3891           0 :     if( this==&rhs )
    3892           0 :         return *this;
    3893             :     jmp_buf _break_jump;
    3894             :     alglib_impl::ae_state _state;
    3895             :     
    3896           0 :     alglib_impl::ae_state_init(&_state);
    3897           0 :     if( setjmp(_break_jump) )
    3898             :     {
    3899             : #if !defined(AE_NO_EXCEPTIONS)
    3900           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3901             : #else
    3902             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3903             :         return *this;
    3904             : #endif
    3905             :     }
    3906           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3907           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: nleqstate assignment constructor failure (destination is not initialized)", &_state);
    3908           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: nleqstate assignment constructor failure (source is not initialized)", &_state);
    3909           0 :     alglib_impl::_nleqstate_destroy(p_struct);
    3910           0 :     memset(p_struct, 0, sizeof(alglib_impl::nleqstate));
    3911           0 :     alglib_impl::_nleqstate_init_copy(p_struct, const_cast<alglib_impl::nleqstate*>(rhs.p_struct), &_state, ae_false);
    3912           0 :     ae_state_clear(&_state);
    3913           0 :     return *this;
    3914             : }
    3915             : 
    3916           0 : _nleqstate_owner::~_nleqstate_owner()
    3917             : {
    3918           0 :     if( p_struct!=NULL )
    3919             :     {
    3920           0 :         alglib_impl::_nleqstate_destroy(p_struct);
    3921           0 :         ae_free(p_struct);
    3922             :     }
    3923           0 : }
    3924             : 
    3925           0 : alglib_impl::nleqstate* _nleqstate_owner::c_ptr()
    3926             : {
    3927           0 :     return p_struct;
    3928             : }
    3929             : 
    3930           0 : alglib_impl::nleqstate* _nleqstate_owner::c_ptr() const
    3931             : {
    3932           0 :     return const_cast<alglib_impl::nleqstate*>(p_struct);
    3933             : }
    3934           0 : nleqstate::nleqstate() : _nleqstate_owner() ,needf(p_struct->needf),needfij(p_struct->needfij),xupdated(p_struct->xupdated),f(p_struct->f),fi(&p_struct->fi),j(&p_struct->j),x(&p_struct->x)
    3935             : {
    3936           0 : }
    3937             : 
    3938           0 : nleqstate::nleqstate(const nleqstate &rhs):_nleqstate_owner(rhs) ,needf(p_struct->needf),needfij(p_struct->needfij),xupdated(p_struct->xupdated),f(p_struct->f),fi(&p_struct->fi),j(&p_struct->j),x(&p_struct->x)
    3939             : {
    3940           0 : }
    3941             : 
    3942           0 : nleqstate& nleqstate::operator=(const nleqstate &rhs)
    3943             : {
    3944           0 :     if( this==&rhs )
    3945           0 :         return *this;
    3946           0 :     _nleqstate_owner::operator=(rhs);
    3947           0 :     return *this;
    3948             : }
    3949             : 
    3950           0 : nleqstate::~nleqstate()
    3951             : {
    3952           0 : }
    3953             : 
    3954             : 
    3955             : /*************************************************************************
    3956             : 
    3957             : *************************************************************************/
    3958           0 : _nleqreport_owner::_nleqreport_owner()
    3959             : {
    3960             :     jmp_buf _break_jump;
    3961             :     alglib_impl::ae_state _state;
    3962             :     
    3963           0 :     alglib_impl::ae_state_init(&_state);
    3964           0 :     if( setjmp(_break_jump) )
    3965             :     {
    3966           0 :         if( p_struct!=NULL )
    3967             :         {
    3968           0 :             alglib_impl::_nleqreport_destroy(p_struct);
    3969           0 :             alglib_impl::ae_free(p_struct);
    3970             :         }
    3971           0 :         p_struct = NULL;
    3972             : #if !defined(AE_NO_EXCEPTIONS)
    3973           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    3974             : #else
    3975             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    3976             :         return;
    3977             : #endif
    3978             :     }
    3979           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    3980           0 :     p_struct = NULL;
    3981           0 :     p_struct = (alglib_impl::nleqreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::nleqreport), &_state);
    3982           0 :     memset(p_struct, 0, sizeof(alglib_impl::nleqreport));
    3983           0 :     alglib_impl::_nleqreport_init(p_struct, &_state, ae_false);
    3984           0 :     ae_state_clear(&_state);
    3985           0 : }
    3986             : 
    3987           0 : _nleqreport_owner::_nleqreport_owner(const _nleqreport_owner &rhs)
    3988             : {
    3989             :     jmp_buf _break_jump;
    3990             :     alglib_impl::ae_state _state;
    3991             :     
    3992           0 :     alglib_impl::ae_state_init(&_state);
    3993           0 :     if( setjmp(_break_jump) )
    3994             :     {
    3995           0 :         if( p_struct!=NULL )
    3996             :         {
    3997           0 :             alglib_impl::_nleqreport_destroy(p_struct);
    3998           0 :             alglib_impl::ae_free(p_struct);
    3999             :         }
    4000           0 :         p_struct = NULL;
    4001             : #if !defined(AE_NO_EXCEPTIONS)
    4002           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    4003             : #else
    4004             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    4005             :         return;
    4006             : #endif
    4007             :     }
    4008           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    4009           0 :     p_struct = NULL;
    4010           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: nleqreport copy constructor failure (source is not initialized)", &_state);
    4011           0 :     p_struct = (alglib_impl::nleqreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::nleqreport), &_state);
    4012           0 :     memset(p_struct, 0, sizeof(alglib_impl::nleqreport));
    4013           0 :     alglib_impl::_nleqreport_init_copy(p_struct, const_cast<alglib_impl::nleqreport*>(rhs.p_struct), &_state, ae_false);
    4014           0 :     ae_state_clear(&_state);
    4015           0 : }
    4016             : 
    4017           0 : _nleqreport_owner& _nleqreport_owner::operator=(const _nleqreport_owner &rhs)
    4018             : {
    4019           0 :     if( this==&rhs )
    4020           0 :         return *this;
    4021             :     jmp_buf _break_jump;
    4022             :     alglib_impl::ae_state _state;
    4023             :     
    4024           0 :     alglib_impl::ae_state_init(&_state);
    4025           0 :     if( setjmp(_break_jump) )
    4026             :     {
    4027             : #if !defined(AE_NO_EXCEPTIONS)
    4028           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    4029             : #else
    4030             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    4031             :         return *this;
    4032             : #endif
    4033             :     }
    4034           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    4035           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: nleqreport assignment constructor failure (destination is not initialized)", &_state);
    4036           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: nleqreport assignment constructor failure (source is not initialized)", &_state);
    4037           0 :     alglib_impl::_nleqreport_destroy(p_struct);
    4038           0 :     memset(p_struct, 0, sizeof(alglib_impl::nleqreport));
    4039           0 :     alglib_impl::_nleqreport_init_copy(p_struct, const_cast<alglib_impl::nleqreport*>(rhs.p_struct), &_state, ae_false);
    4040           0 :     ae_state_clear(&_state);
    4041           0 :     return *this;
    4042             : }
    4043             : 
    4044           0 : _nleqreport_owner::~_nleqreport_owner()
    4045             : {
    4046           0 :     if( p_struct!=NULL )
    4047             :     {
    4048           0 :         alglib_impl::_nleqreport_destroy(p_struct);
    4049           0 :         ae_free(p_struct);
    4050             :     }
    4051           0 : }
    4052             : 
    4053           0 : alglib_impl::nleqreport* _nleqreport_owner::c_ptr()
    4054             : {
    4055           0 :     return p_struct;
    4056             : }
    4057             : 
    4058           0 : alglib_impl::nleqreport* _nleqreport_owner::c_ptr() const
    4059             : {
    4060           0 :     return const_cast<alglib_impl::nleqreport*>(p_struct);
    4061             : }
    4062           0 : nleqreport::nleqreport() : _nleqreport_owner() ,iterationscount(p_struct->iterationscount),nfunc(p_struct->nfunc),njac(p_struct->njac),terminationtype(p_struct->terminationtype)
    4063             : {
    4064           0 : }
    4065             : 
    4066           0 : nleqreport::nleqreport(const nleqreport &rhs):_nleqreport_owner(rhs) ,iterationscount(p_struct->iterationscount),nfunc(p_struct->nfunc),njac(p_struct->njac),terminationtype(p_struct->terminationtype)
    4067             : {
    4068           0 : }
    4069             : 
    4070           0 : nleqreport& nleqreport::operator=(const nleqreport &rhs)
    4071             : {
    4072           0 :     if( this==&rhs )
    4073           0 :         return *this;
    4074           0 :     _nleqreport_owner::operator=(rhs);
    4075           0 :     return *this;
    4076             : }
    4077             : 
    4078           0 : nleqreport::~nleqreport()
    4079             : {
    4080           0 : }
    4081             : 
    4082             : /*************************************************************************
    4083             :                 LEVENBERG-MARQUARDT-LIKE NONLINEAR SOLVER
    4084             : 
    4085             : DESCRIPTION:
    4086             : This algorithm solves system of nonlinear equations
    4087             :     F[0](x[0], ..., x[n-1])   = 0
    4088             :     F[1](x[0], ..., x[n-1])   = 0
    4089             :     ...
    4090             :     F[M-1](x[0], ..., x[n-1]) = 0
    4091             : with M/N do not necessarily coincide.  Algorithm  converges  quadratically
    4092             : under following conditions:
    4093             :     * the solution set XS is nonempty
    4094             :     * for some xs in XS there exist such neighbourhood N(xs) that:
    4095             :       * vector function F(x) and its Jacobian J(x) are continuously
    4096             :         differentiable on N
    4097             :       * ||F(x)|| provides local error bound on N, i.e. there  exists  such
    4098             :         c1, that ||F(x)||>c1*distance(x,XS)
    4099             : Note that these conditions are much more weaker than usual non-singularity
    4100             : conditions. For example, algorithm will converge for any  affine  function
    4101             : F (whether its Jacobian singular or not).
    4102             : 
    4103             : 
    4104             : REQUIREMENTS:
    4105             : Algorithm will request following information during its operation:
    4106             : * function vector F[] and Jacobian matrix at given point X
    4107             : * value of merit function f(x)=F[0]^2(x)+...+F[M-1]^2(x) at given point X
    4108             : 
    4109             : 
    4110             : USAGE:
    4111             : 1. User initializes algorithm state with NLEQCreateLM() call
    4112             : 2. User tunes solver parameters with  NLEQSetCond(),  NLEQSetStpMax()  and
    4113             :    other functions
    4114             : 3. User  calls  NLEQSolve()  function  which  takes  algorithm  state  and
    4115             :    pointers (delegates, etc.) to callback functions which calculate  merit
    4116             :    function value and Jacobian.
    4117             : 4. User calls NLEQResults() to get solution
    4118             : 5. Optionally, user may call NLEQRestartFrom() to  solve  another  problem
    4119             :    with same parameters (N/M) but another starting  point  and/or  another
    4120             :    function vector. NLEQRestartFrom() allows to reuse already  initialized
    4121             :    structure.
    4122             : 
    4123             : 
    4124             : INPUT PARAMETERS:
    4125             :     N       -   space dimension, N>1:
    4126             :                 * if provided, only leading N elements of X are used
    4127             :                 * if not provided, determined automatically from size of X
    4128             :     M       -   system size
    4129             :     X       -   starting point
    4130             : 
    4131             : 
    4132             : OUTPUT PARAMETERS:
    4133             :     State   -   structure which stores algorithm state
    4134             : 
    4135             : 
    4136             : NOTES:
    4137             : 1. you may tune stopping conditions with NLEQSetCond() function
    4138             : 2. if target function contains exp() or other fast growing functions,  and
    4139             :    optimization algorithm makes too large steps which leads  to  overflow,
    4140             :    use NLEQSetStpMax() function to bound algorithm's steps.
    4141             : 3. this  algorithm  is  a  slightly  modified implementation of the method
    4142             :    described  in  'Levenberg-Marquardt  method  for constrained  nonlinear
    4143             :    equations with strong local convergence properties' by Christian Kanzow
    4144             :    Nobuo Yamashita and Masao Fukushima and further  developed  in  'On the
    4145             :    convergence of a New Levenberg-Marquardt Method'  by  Jin-yan  Fan  and
    4146             :    Ya-Xiang Yuan.
    4147             : 
    4148             : 
    4149             :   -- ALGLIB --
    4150             :      Copyright 20.08.2009 by Bochkanov Sergey
    4151             : *************************************************************************/
    4152           0 : void nleqcreatelm(const ae_int_t n, const ae_int_t m, const real_1d_array &x, nleqstate &state, const xparams _xparams)
    4153             : {
    4154             :     jmp_buf _break_jump;
    4155             :     alglib_impl::ae_state _alglib_env_state;
    4156           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4157           0 :     if( setjmp(_break_jump) )
    4158             :     {
    4159             : #if !defined(AE_NO_EXCEPTIONS)
    4160           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4161             : #else
    4162             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4163             :         return;
    4164             : #endif
    4165             :     }
    4166           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4167           0 :     if( _xparams.flags!=0x0 )
    4168           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4169           0 :     alglib_impl::nleqcreatelm(n, m, const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::nleqstate*>(state.c_ptr()), &_alglib_env_state);
    4170           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4171           0 :     return;
    4172             : }
    4173             : 
    4174             : /*************************************************************************
    4175             :                 LEVENBERG-MARQUARDT-LIKE NONLINEAR SOLVER
    4176             : 
    4177             : DESCRIPTION:
    4178             : This algorithm solves system of nonlinear equations
    4179             :     F[0](x[0], ..., x[n-1])   = 0
    4180             :     F[1](x[0], ..., x[n-1])   = 0
    4181             :     ...
    4182             :     F[M-1](x[0], ..., x[n-1]) = 0
    4183             : with M/N do not necessarily coincide.  Algorithm  converges  quadratically
    4184             : under following conditions:
    4185             :     * the solution set XS is nonempty
    4186             :     * for some xs in XS there exist such neighbourhood N(xs) that:
    4187             :       * vector function F(x) and its Jacobian J(x) are continuously
    4188             :         differentiable on N
    4189             :       * ||F(x)|| provides local error bound on N, i.e. there  exists  such
    4190             :         c1, that ||F(x)||>c1*distance(x,XS)
    4191             : Note that these conditions are much more weaker than usual non-singularity
    4192             : conditions. For example, algorithm will converge for any  affine  function
    4193             : F (whether its Jacobian singular or not).
    4194             : 
    4195             : 
    4196             : REQUIREMENTS:
    4197             : Algorithm will request following information during its operation:
    4198             : * function vector F[] and Jacobian matrix at given point X
    4199             : * value of merit function f(x)=F[0]^2(x)+...+F[M-1]^2(x) at given point X
    4200             : 
    4201             : 
    4202             : USAGE:
    4203             : 1. User initializes algorithm state with NLEQCreateLM() call
    4204             : 2. User tunes solver parameters with  NLEQSetCond(),  NLEQSetStpMax()  and
    4205             :    other functions
    4206             : 3. User  calls  NLEQSolve()  function  which  takes  algorithm  state  and
    4207             :    pointers (delegates, etc.) to callback functions which calculate  merit
    4208             :    function value and Jacobian.
    4209             : 4. User calls NLEQResults() to get solution
    4210             : 5. Optionally, user may call NLEQRestartFrom() to  solve  another  problem
    4211             :    with same parameters (N/M) but another starting  point  and/or  another
    4212             :    function vector. NLEQRestartFrom() allows to reuse already  initialized
    4213             :    structure.
    4214             : 
    4215             : 
    4216             : INPUT PARAMETERS:
    4217             :     N       -   space dimension, N>1:
    4218             :                 * if provided, only leading N elements of X are used
    4219             :                 * if not provided, determined automatically from size of X
    4220             :     M       -   system size
    4221             :     X       -   starting point
    4222             : 
    4223             : 
    4224             : OUTPUT PARAMETERS:
    4225             :     State   -   structure which stores algorithm state
    4226             : 
    4227             : 
    4228             : NOTES:
    4229             : 1. you may tune stopping conditions with NLEQSetCond() function
    4230             : 2. if target function contains exp() or other fast growing functions,  and
    4231             :    optimization algorithm makes too large steps which leads  to  overflow,
    4232             :    use NLEQSetStpMax() function to bound algorithm's steps.
    4233             : 3. this  algorithm  is  a  slightly  modified implementation of the method
    4234             :    described  in  'Levenberg-Marquardt  method  for constrained  nonlinear
    4235             :    equations with strong local convergence properties' by Christian Kanzow
    4236             :    Nobuo Yamashita and Masao Fukushima and further  developed  in  'On the
    4237             :    convergence of a New Levenberg-Marquardt Method'  by  Jin-yan  Fan  and
    4238             :    Ya-Xiang Yuan.
    4239             : 
    4240             : 
    4241             :   -- ALGLIB --
    4242             :      Copyright 20.08.2009 by Bochkanov Sergey
    4243             : *************************************************************************/
    4244             : #if !defined(AE_NO_EXCEPTIONS)
    4245           0 : void nleqcreatelm(const ae_int_t m, const real_1d_array &x, nleqstate &state, const xparams _xparams)
    4246             : {
    4247             :     jmp_buf _break_jump;
    4248             :     alglib_impl::ae_state _alglib_env_state;    
    4249             :     ae_int_t n;
    4250             : 
    4251           0 :     n = x.length();
    4252           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4253           0 :     if( setjmp(_break_jump) )
    4254           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4255           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4256           0 :     if( _xparams.flags!=0x0 )
    4257           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4258           0 :     alglib_impl::nleqcreatelm(n, m, const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::nleqstate*>(state.c_ptr()), &_alglib_env_state);
    4259             : 
    4260           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4261           0 :     return;
    4262             : }
    4263             : #endif
    4264             : 
    4265             : /*************************************************************************
    4266             : This function sets stopping conditions for the nonlinear solver
    4267             : 
    4268             : INPUT PARAMETERS:
    4269             :     State   -   structure which stores algorithm state
    4270             :     EpsF    -   >=0
    4271             :                 The subroutine finishes  its work if on k+1-th iteration
    4272             :                 the condition ||F||<=EpsF is satisfied
    4273             :     MaxIts  -   maximum number of iterations. If MaxIts=0, the  number  of
    4274             :                 iterations is unlimited.
    4275             : 
    4276             : Passing EpsF=0 and MaxIts=0 simultaneously will lead to  automatic
    4277             : stopping criterion selection (small EpsF).
    4278             : 
    4279             : NOTES:
    4280             : 
    4281             :   -- ALGLIB --
    4282             :      Copyright 20.08.2010 by Bochkanov Sergey
    4283             : *************************************************************************/
    4284           0 : void nleqsetcond(const nleqstate &state, const double epsf, const ae_int_t maxits, const xparams _xparams)
    4285             : {
    4286             :     jmp_buf _break_jump;
    4287             :     alglib_impl::ae_state _alglib_env_state;
    4288           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4289           0 :     if( setjmp(_break_jump) )
    4290             :     {
    4291             : #if !defined(AE_NO_EXCEPTIONS)
    4292           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4293             : #else
    4294             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4295             :         return;
    4296             : #endif
    4297             :     }
    4298           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4299           0 :     if( _xparams.flags!=0x0 )
    4300           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4301           0 :     alglib_impl::nleqsetcond(const_cast<alglib_impl::nleqstate*>(state.c_ptr()), epsf, maxits, &_alglib_env_state);
    4302           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4303           0 :     return;
    4304             : }
    4305             : 
    4306             : /*************************************************************************
    4307             : This function turns on/off reporting.
    4308             : 
    4309             : INPUT PARAMETERS:
    4310             :     State   -   structure which stores algorithm state
    4311             :     NeedXRep-   whether iteration reports are needed or not
    4312             : 
    4313             : If NeedXRep is True, algorithm will call rep() callback function if  it is
    4314             : provided to NLEQSolve().
    4315             : 
    4316             :   -- ALGLIB --
    4317             :      Copyright 20.08.2010 by Bochkanov Sergey
    4318             : *************************************************************************/
    4319           0 : void nleqsetxrep(const nleqstate &state, const bool needxrep, const xparams _xparams)
    4320             : {
    4321             :     jmp_buf _break_jump;
    4322             :     alglib_impl::ae_state _alglib_env_state;
    4323           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4324           0 :     if( setjmp(_break_jump) )
    4325             :     {
    4326             : #if !defined(AE_NO_EXCEPTIONS)
    4327           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4328             : #else
    4329             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4330             :         return;
    4331             : #endif
    4332             :     }
    4333           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4334           0 :     if( _xparams.flags!=0x0 )
    4335           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4336           0 :     alglib_impl::nleqsetxrep(const_cast<alglib_impl::nleqstate*>(state.c_ptr()), needxrep, &_alglib_env_state);
    4337           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4338           0 :     return;
    4339             : }
    4340             : 
    4341             : /*************************************************************************
    4342             : This function sets maximum step length
    4343             : 
    4344             : INPUT PARAMETERS:
    4345             :     State   -   structure which stores algorithm state
    4346             :     StpMax  -   maximum step length, >=0. Set StpMax to 0.0,  if you don't
    4347             :                 want to limit step length.
    4348             : 
    4349             : Use this subroutine when target function  contains  exp()  or  other  fast
    4350             : growing functions, and algorithm makes  too  large  steps  which  lead  to
    4351             : overflow. This function allows us to reject steps that are too large  (and
    4352             : therefore expose us to the possible overflow) without actually calculating
    4353             : function value at the x+stp*d.
    4354             : 
    4355             :   -- ALGLIB --
    4356             :      Copyright 20.08.2010 by Bochkanov Sergey
    4357             : *************************************************************************/
    4358           0 : void nleqsetstpmax(const nleqstate &state, const double stpmax, const xparams _xparams)
    4359             : {
    4360             :     jmp_buf _break_jump;
    4361             :     alglib_impl::ae_state _alglib_env_state;
    4362           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4363           0 :     if( setjmp(_break_jump) )
    4364             :     {
    4365             : #if !defined(AE_NO_EXCEPTIONS)
    4366           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4367             : #else
    4368             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4369             :         return;
    4370             : #endif
    4371             :     }
    4372           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4373           0 :     if( _xparams.flags!=0x0 )
    4374           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4375           0 :     alglib_impl::nleqsetstpmax(const_cast<alglib_impl::nleqstate*>(state.c_ptr()), stpmax, &_alglib_env_state);
    4376           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4377           0 :     return;
    4378             : }
    4379             : 
    4380             : /*************************************************************************
    4381             : This function provides reverse communication interface
    4382             : Reverse communication interface is not documented or recommended to use.
    4383             : See below for functions which provide better documented API
    4384             : *************************************************************************/
    4385           0 : bool nleqiteration(const nleqstate &state, const xparams _xparams)
    4386             : {
    4387             :     jmp_buf _break_jump;
    4388             :     alglib_impl::ae_state _alglib_env_state;
    4389           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4390           0 :     if( setjmp(_break_jump) )
    4391             :     {
    4392             : #if !defined(AE_NO_EXCEPTIONS)
    4393           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4394             : #else
    4395             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4396             :         return 0;
    4397             : #endif
    4398             :     }
    4399           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4400           0 :     if( _xparams.flags!=0x0 )
    4401           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4402           0 :     ae_bool result = alglib_impl::nleqiteration(const_cast<alglib_impl::nleqstate*>(state.c_ptr()), &_alglib_env_state);
    4403           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4404           0 :     return *(reinterpret_cast<bool*>(&result));
    4405             : }
    4406             : 
    4407             : 
    4408           0 : void nleqsolve(nleqstate &state,
    4409             :     void (*func)(const real_1d_array &x, double &func, void *ptr),
    4410             :     void  (*jac)(const real_1d_array &x, real_1d_array &fi, real_2d_array &jac, void *ptr),
    4411             :     void  (*rep)(const real_1d_array &x, double func, void *ptr), 
    4412             :     void *ptr,
    4413             :     const xparams _xparams)
    4414             : {
    4415             :     jmp_buf _break_jump;
    4416             :     alglib_impl::ae_state _alglib_env_state;
    4417           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4418           0 :     if( setjmp(_break_jump) )
    4419             :     {
    4420             : #if !defined(AE_NO_EXCEPTIONS)
    4421           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4422             : #else
    4423             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4424             :         return;
    4425             : #endif
    4426             :     }
    4427           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4428           0 :     if( _xparams.flags!=0x0 )
    4429           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4430           0 :     alglib_impl::ae_assert(func!=NULL, "ALGLIB: error in 'nleqsolve()' (func is NULL)", &_alglib_env_state);
    4431           0 :     alglib_impl::ae_assert(jac!=NULL,  "ALGLIB: error in 'nleqsolve()' (jac is NULL)", &_alglib_env_state);
    4432           0 :     while( alglib_impl::nleqiteration(state.c_ptr(), &_alglib_env_state) )
    4433             :     {
    4434             :         _ALGLIB_CALLBACK_EXCEPTION_GUARD_BEGIN
    4435           0 :                 if( state.needf )
    4436             :                 {
    4437           0 :                     func(state.x, state.f, ptr);
    4438           0 :                     continue;
    4439             :                 }
    4440           0 :                 if( state.needfij )
    4441             :                 {
    4442           0 :                     jac(state.x, state.fi, state.j, ptr);
    4443           0 :                     continue;
    4444             :                 }
    4445           0 :         if( state.xupdated )
    4446             :         {
    4447           0 :             if( rep!=NULL )
    4448           0 :                 rep(state.x, state.f, ptr);
    4449           0 :             continue;
    4450             :         }
    4451           0 :         goto lbl_no_callback;
    4452           0 :         _ALGLIB_CALLBACK_EXCEPTION_GUARD_END
    4453           0 :     lbl_no_callback:
    4454           0 :         alglib_impl::ae_assert(ae_false, "ALGLIB: error in 'nleqsolve' (some derivatives were not provided?)", &_alglib_env_state);
    4455             :     }
    4456           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4457           0 : }
    4458             : 
    4459             : 
    4460             : 
    4461             : /*************************************************************************
    4462             : NLEQ solver results
    4463             : 
    4464             : INPUT PARAMETERS:
    4465             :     State   -   algorithm state.
    4466             : 
    4467             : OUTPUT PARAMETERS:
    4468             :     X       -   array[0..N-1], solution
    4469             :     Rep     -   optimization report:
    4470             :                 * Rep.TerminationType completetion code:
    4471             :                     * -4    ERROR:  algorithm   has   converged   to   the
    4472             :                             stationary point Xf which is local minimum  of
    4473             :                             f=F[0]^2+...+F[m-1]^2, but is not solution  of
    4474             :                             nonlinear system.
    4475             :                     *  1    sqrt(f)<=EpsF.
    4476             :                     *  5    MaxIts steps was taken
    4477             :                     *  7    stopping conditions are too stringent,
    4478             :                             further improvement is impossible
    4479             :                 * Rep.IterationsCount contains iterations count
    4480             :                 * NFEV countains number of function calculations
    4481             :                 * ActiveConstraints contains number of active constraints
    4482             : 
    4483             :   -- ALGLIB --
    4484             :      Copyright 20.08.2009 by Bochkanov Sergey
    4485             : *************************************************************************/
    4486           0 : void nleqresults(const nleqstate &state, real_1d_array &x, nleqreport &rep, const xparams _xparams)
    4487             : {
    4488             :     jmp_buf _break_jump;
    4489             :     alglib_impl::ae_state _alglib_env_state;
    4490           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4491           0 :     if( setjmp(_break_jump) )
    4492             :     {
    4493             : #if !defined(AE_NO_EXCEPTIONS)
    4494           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4495             : #else
    4496             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4497             :         return;
    4498             : #endif
    4499             :     }
    4500           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4501           0 :     if( _xparams.flags!=0x0 )
    4502           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4503           0 :     alglib_impl::nleqresults(const_cast<alglib_impl::nleqstate*>(state.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::nleqreport*>(rep.c_ptr()), &_alglib_env_state);
    4504           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4505           0 :     return;
    4506             : }
    4507             : 
    4508             : /*************************************************************************
    4509             : NLEQ solver results
    4510             : 
    4511             : Buffered implementation of NLEQResults(), which uses pre-allocated  buffer
    4512             : to store X[]. If buffer size is  too  small,  it  resizes  buffer.  It  is
    4513             : intended to be used in the inner cycles of performance critical algorithms
    4514             : where array reallocation penalty is too large to be ignored.
    4515             : 
    4516             :   -- ALGLIB --
    4517             :      Copyright 20.08.2009 by Bochkanov Sergey
    4518             : *************************************************************************/
    4519           0 : void nleqresultsbuf(const nleqstate &state, real_1d_array &x, nleqreport &rep, const xparams _xparams)
    4520             : {
    4521             :     jmp_buf _break_jump;
    4522             :     alglib_impl::ae_state _alglib_env_state;
    4523           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4524           0 :     if( setjmp(_break_jump) )
    4525             :     {
    4526             : #if !defined(AE_NO_EXCEPTIONS)
    4527           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4528             : #else
    4529             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4530             :         return;
    4531             : #endif
    4532             :     }
    4533           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4534           0 :     if( _xparams.flags!=0x0 )
    4535           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4536           0 :     alglib_impl::nleqresultsbuf(const_cast<alglib_impl::nleqstate*>(state.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::nleqreport*>(rep.c_ptr()), &_alglib_env_state);
    4537           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4538           0 :     return;
    4539             : }
    4540             : 
    4541             : /*************************************************************************
    4542             : This  subroutine  restarts  CG  algorithm from new point. All optimization
    4543             : parameters are left unchanged.
    4544             : 
    4545             : This  function  allows  to  solve multiple  optimization  problems  (which
    4546             : must have same number of dimensions) without object reallocation penalty.
    4547             : 
    4548             : INPUT PARAMETERS:
    4549             :     State   -   structure used for reverse communication previously
    4550             :                 allocated with MinCGCreate call.
    4551             :     X       -   new starting point.
    4552             :     BndL    -   new lower bounds
    4553             :     BndU    -   new upper bounds
    4554             : 
    4555             :   -- ALGLIB --
    4556             :      Copyright 30.07.2010 by Bochkanov Sergey
    4557             : *************************************************************************/
    4558           0 : void nleqrestartfrom(const nleqstate &state, const real_1d_array &x, const xparams _xparams)
    4559             : {
    4560             :     jmp_buf _break_jump;
    4561             :     alglib_impl::ae_state _alglib_env_state;
    4562           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4563           0 :     if( setjmp(_break_jump) )
    4564             :     {
    4565             : #if !defined(AE_NO_EXCEPTIONS)
    4566           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4567             : #else
    4568             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4569             :         return;
    4570             : #endif
    4571             :     }
    4572           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4573           0 :     if( _xparams.flags!=0x0 )
    4574           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4575           0 :     alglib_impl::nleqrestartfrom(const_cast<alglib_impl::nleqstate*>(state.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    4576           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4577           0 :     return;
    4578             : }
    4579             : #endif
    4580             : 
    4581             : #if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
    4582             : /*************************************************************************
    4583             : This structure is a sparse solver report.
    4584             : 
    4585             : Following fields can be accessed by users:
    4586             : *************************************************************************/
    4587           0 : _sparsesolverreport_owner::_sparsesolverreport_owner()
    4588             : {
    4589             :     jmp_buf _break_jump;
    4590             :     alglib_impl::ae_state _state;
    4591             :     
    4592           0 :     alglib_impl::ae_state_init(&_state);
    4593           0 :     if( setjmp(_break_jump) )
    4594             :     {
    4595           0 :         if( p_struct!=NULL )
    4596             :         {
    4597           0 :             alglib_impl::_sparsesolverreport_destroy(p_struct);
    4598           0 :             alglib_impl::ae_free(p_struct);
    4599             :         }
    4600           0 :         p_struct = NULL;
    4601             : #if !defined(AE_NO_EXCEPTIONS)
    4602           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    4603             : #else
    4604             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    4605             :         return;
    4606             : #endif
    4607             :     }
    4608           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    4609           0 :     p_struct = NULL;
    4610           0 :     p_struct = (alglib_impl::sparsesolverreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::sparsesolverreport), &_state);
    4611           0 :     memset(p_struct, 0, sizeof(alglib_impl::sparsesolverreport));
    4612           0 :     alglib_impl::_sparsesolverreport_init(p_struct, &_state, ae_false);
    4613           0 :     ae_state_clear(&_state);
    4614           0 : }
    4615             : 
    4616           0 : _sparsesolverreport_owner::_sparsesolverreport_owner(const _sparsesolverreport_owner &rhs)
    4617             : {
    4618             :     jmp_buf _break_jump;
    4619             :     alglib_impl::ae_state _state;
    4620             :     
    4621           0 :     alglib_impl::ae_state_init(&_state);
    4622           0 :     if( setjmp(_break_jump) )
    4623             :     {
    4624           0 :         if( p_struct!=NULL )
    4625             :         {
    4626           0 :             alglib_impl::_sparsesolverreport_destroy(p_struct);
    4627           0 :             alglib_impl::ae_free(p_struct);
    4628             :         }
    4629           0 :         p_struct = NULL;
    4630             : #if !defined(AE_NO_EXCEPTIONS)
    4631           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    4632             : #else
    4633             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    4634             :         return;
    4635             : #endif
    4636             :     }
    4637           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    4638           0 :     p_struct = NULL;
    4639           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: sparsesolverreport copy constructor failure (source is not initialized)", &_state);
    4640           0 :     p_struct = (alglib_impl::sparsesolverreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::sparsesolverreport), &_state);
    4641           0 :     memset(p_struct, 0, sizeof(alglib_impl::sparsesolverreport));
    4642           0 :     alglib_impl::_sparsesolverreport_init_copy(p_struct, const_cast<alglib_impl::sparsesolverreport*>(rhs.p_struct), &_state, ae_false);
    4643           0 :     ae_state_clear(&_state);
    4644           0 : }
    4645             : 
    4646           0 : _sparsesolverreport_owner& _sparsesolverreport_owner::operator=(const _sparsesolverreport_owner &rhs)
    4647             : {
    4648           0 :     if( this==&rhs )
    4649           0 :         return *this;
    4650             :     jmp_buf _break_jump;
    4651             :     alglib_impl::ae_state _state;
    4652             :     
    4653           0 :     alglib_impl::ae_state_init(&_state);
    4654           0 :     if( setjmp(_break_jump) )
    4655             :     {
    4656             : #if !defined(AE_NO_EXCEPTIONS)
    4657           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    4658             : #else
    4659             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    4660             :         return *this;
    4661             : #endif
    4662             :     }
    4663           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    4664           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: sparsesolverreport assignment constructor failure (destination is not initialized)", &_state);
    4665           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: sparsesolverreport assignment constructor failure (source is not initialized)", &_state);
    4666           0 :     alglib_impl::_sparsesolverreport_destroy(p_struct);
    4667           0 :     memset(p_struct, 0, sizeof(alglib_impl::sparsesolverreport));
    4668           0 :     alglib_impl::_sparsesolverreport_init_copy(p_struct, const_cast<alglib_impl::sparsesolverreport*>(rhs.p_struct), &_state, ae_false);
    4669           0 :     ae_state_clear(&_state);
    4670           0 :     return *this;
    4671             : }
    4672             : 
    4673           0 : _sparsesolverreport_owner::~_sparsesolverreport_owner()
    4674             : {
    4675           0 :     if( p_struct!=NULL )
    4676             :     {
    4677           0 :         alglib_impl::_sparsesolverreport_destroy(p_struct);
    4678           0 :         ae_free(p_struct);
    4679             :     }
    4680           0 : }
    4681             : 
    4682           0 : alglib_impl::sparsesolverreport* _sparsesolverreport_owner::c_ptr()
    4683             : {
    4684           0 :     return p_struct;
    4685             : }
    4686             : 
    4687           0 : alglib_impl::sparsesolverreport* _sparsesolverreport_owner::c_ptr() const
    4688             : {
    4689           0 :     return const_cast<alglib_impl::sparsesolverreport*>(p_struct);
    4690             : }
    4691           0 : sparsesolverreport::sparsesolverreport() : _sparsesolverreport_owner() ,terminationtype(p_struct->terminationtype)
    4692             : {
    4693           0 : }
    4694             : 
    4695           0 : sparsesolverreport::sparsesolverreport(const sparsesolverreport &rhs):_sparsesolverreport_owner(rhs) ,terminationtype(p_struct->terminationtype)
    4696             : {
    4697           0 : }
    4698             : 
    4699           0 : sparsesolverreport& sparsesolverreport::operator=(const sparsesolverreport &rhs)
    4700             : {
    4701           0 :     if( this==&rhs )
    4702           0 :         return *this;
    4703           0 :     _sparsesolverreport_owner::operator=(rhs);
    4704           0 :     return *this;
    4705             : }
    4706             : 
    4707           0 : sparsesolverreport::~sparsesolverreport()
    4708             : {
    4709           0 : }
    4710             : 
    4711             : /*************************************************************************
    4712             : Sparse linear solver for A*x=b with N*N  sparse  real  symmetric  positive
    4713             : definite matrix A, N*1 vectors x and b.
    4714             : 
    4715             : This solver  converts  input  matrix  to  SKS  format,  performs  Cholesky
    4716             : factorization using  SKS  Cholesky  subroutine  (works  well  for  limited
    4717             : bandwidth matrices) and uses sparse triangular solvers to get solution  of
    4718             : the original system.
    4719             : 
    4720             : INPUT PARAMETERS
    4721             :     A       -   sparse matrix, must be NxN exactly
    4722             :     IsUpper -   which half of A is provided (another half is ignored)
    4723             :     B       -   array[0..N-1], right part
    4724             : 
    4725             : OUTPUT PARAMETERS
    4726             :     X       -   array[N], it contains:
    4727             :                 * rep.terminationtype>0    =>  solution
    4728             :                 * rep.terminationtype=-3   =>  filled by zeros
    4729             :     Rep     -   solver report, following fields are set:
    4730             :                 * rep.terminationtype - solver status; >0 for success,
    4731             :                   set to -3 on failure (degenerate or non-SPD system).
    4732             : 
    4733             :   -- ALGLIB --
    4734             :      Copyright 26.12.2017 by Bochkanov Sergey
    4735             : *************************************************************************/
    4736           0 : void sparsespdsolvesks(const sparsematrix &a, const bool isupper, const real_1d_array &b, real_1d_array &x, sparsesolverreport &rep, const xparams _xparams)
    4737             : {
    4738             :     jmp_buf _break_jump;
    4739             :     alglib_impl::ae_state _alglib_env_state;
    4740           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4741           0 :     if( setjmp(_break_jump) )
    4742             :     {
    4743             : #if !defined(AE_NO_EXCEPTIONS)
    4744           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4745             : #else
    4746             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4747             :         return;
    4748             : #endif
    4749             :     }
    4750           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4751           0 :     if( _xparams.flags!=0x0 )
    4752           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4753           0 :     alglib_impl::sparsespdsolvesks(const_cast<alglib_impl::sparsematrix*>(a.c_ptr()), isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::sparsesolverreport*>(rep.c_ptr()), &_alglib_env_state);
    4754           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4755           0 :     return;
    4756             : }
    4757             : 
    4758             : /*************************************************************************
    4759             : Sparse linear solver for A*x=b with N*N  sparse  real  symmetric  positive
    4760             : definite matrix A, N*1 vectors x and b.
    4761             : 
    4762             : This solver  converts  input  matrix  to  CRS  format,  performs  Cholesky
    4763             : factorization using supernodal Cholesky  decomposition  with  permutation-
    4764             : reducing ordering and uses sparse triangular solver to get solution of the
    4765             : original system.
    4766             : 
    4767             : INPUT PARAMETERS
    4768             :     A       -   sparse matrix, must be NxN exactly
    4769             :     IsUpper -   which half of A is provided (another half is ignored)
    4770             :     B       -   array[N], right part
    4771             : 
    4772             : OUTPUT PARAMETERS
    4773             :     X       -   array[N], it contains:
    4774             :                 * rep.terminationtype>0    =>  solution
    4775             :                 * rep.terminationtype=-3   =>  filled by zeros
    4776             :     Rep     -   solver report, following fields are set:
    4777             :                 * rep.terminationtype - solver status; >0 for success,
    4778             :                   set to -3 on failure (degenerate or non-SPD system).
    4779             : 
    4780             :   -- ALGLIB --
    4781             :      Copyright 26.12.2017 by Bochkanov Sergey
    4782             : *************************************************************************/
    4783           0 : void sparsespdsolve(const sparsematrix &a, const bool isupper, const real_1d_array &b, real_1d_array &x, sparsesolverreport &rep, const xparams _xparams)
    4784             : {
    4785             :     jmp_buf _break_jump;
    4786             :     alglib_impl::ae_state _alglib_env_state;
    4787           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4788           0 :     if( setjmp(_break_jump) )
    4789             :     {
    4790             : #if !defined(AE_NO_EXCEPTIONS)
    4791           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4792             : #else
    4793             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4794             :         return;
    4795             : #endif
    4796             :     }
    4797           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4798           0 :     if( _xparams.flags!=0x0 )
    4799           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4800           0 :     alglib_impl::sparsespdsolve(const_cast<alglib_impl::sparsematrix*>(a.c_ptr()), isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::sparsesolverreport*>(rep.c_ptr()), &_alglib_env_state);
    4801           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4802           0 :     return;
    4803             : }
    4804             : 
    4805             : /*************************************************************************
    4806             : Sparse linear solver for A*x=b with N*N real  symmetric  positive definite
    4807             : matrix A given by its Cholesky decomposition, and N*1 vectors x and b.
    4808             : 
    4809             : IMPORTANT: this solver requires input matrix to be in  the  SKS  (Skyline)
    4810             :            or CRS (compressed row storage) format. An  exception  will  be
    4811             :            generated if you pass matrix in some other format.
    4812             : 
    4813             : INPUT PARAMETERS
    4814             :     A       -   sparse NxN matrix stored in CRs or SKS format, must be NxN
    4815             :                 exactly
    4816             :     IsUpper -   which half of A is provided (another half is ignored)
    4817             :     B       -   array[N], right part
    4818             : 
    4819             : OUTPUT PARAMETERS
    4820             :     X       -   array[N], it contains:
    4821             :                 * rep.terminationtype>0    =>  solution
    4822             :                 * rep.terminationtype=-3   =>  filled by zeros
    4823             :     Rep     -   solver report, following fields are set:
    4824             :                 * rep.terminationtype - solver status; >0 for success,
    4825             :                   set to -3 on failure (degenerate or non-SPD system).
    4826             : 
    4827             :   -- ALGLIB --
    4828             :      Copyright 26.12.2017 by Bochkanov Sergey
    4829             : *************************************************************************/
    4830           0 : void sparsespdcholeskysolve(const sparsematrix &a, const bool isupper, const real_1d_array &b, real_1d_array &x, sparsesolverreport &rep, const xparams _xparams)
    4831             : {
    4832             :     jmp_buf _break_jump;
    4833             :     alglib_impl::ae_state _alglib_env_state;
    4834           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4835           0 :     if( setjmp(_break_jump) )
    4836             :     {
    4837             : #if !defined(AE_NO_EXCEPTIONS)
    4838           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4839             : #else
    4840             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4841             :         return;
    4842             : #endif
    4843             :     }
    4844           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4845           0 :     if( _xparams.flags!=0x0 )
    4846           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4847           0 :     alglib_impl::sparsespdcholeskysolve(const_cast<alglib_impl::sparsematrix*>(a.c_ptr()), isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::sparsesolverreport*>(rep.c_ptr()), &_alglib_env_state);
    4848           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4849           0 :     return;
    4850             : }
    4851             : 
    4852             : /*************************************************************************
    4853             : Sparse linear solver for A*x=b with general (nonsymmetric) N*N sparse real
    4854             : matrix A, N*1 vectors x and b.
    4855             : 
    4856             : This solver converts input matrix to CRS format, performs LU factorization
    4857             : and uses sparse triangular solvers to get solution of the original system.
    4858             : 
    4859             : INPUT PARAMETERS
    4860             :     A       -   sparse matrix, must be NxN exactly, any storage format
    4861             :     N       -   size of A, N>0
    4862             :     B       -   array[0..N-1], right part
    4863             : 
    4864             : OUTPUT PARAMETERS
    4865             :     X       -   array[N], it contains:
    4866             :                 * rep.terminationtype>0    =>  solution
    4867             :                 * rep.terminationtype=-3   =>  filled by zeros
    4868             :     Rep     -   solver report, following fields are set:
    4869             :                 * rep.terminationtype - solver status; >0 for success,
    4870             :                   set to -3 on failure (degenerate system).
    4871             : 
    4872             :   -- ALGLIB --
    4873             :      Copyright 26.12.2017 by Bochkanov Sergey
    4874             : *************************************************************************/
    4875           0 : void sparsesolve(const sparsematrix &a, const real_1d_array &b, real_1d_array &x, sparsesolverreport &rep, const xparams _xparams)
    4876             : {
    4877             :     jmp_buf _break_jump;
    4878             :     alglib_impl::ae_state _alglib_env_state;
    4879           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4880           0 :     if( setjmp(_break_jump) )
    4881             :     {
    4882             : #if !defined(AE_NO_EXCEPTIONS)
    4883           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4884             : #else
    4885             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4886             :         return;
    4887             : #endif
    4888             :     }
    4889           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4890           0 :     if( _xparams.flags!=0x0 )
    4891           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4892           0 :     alglib_impl::sparsesolve(const_cast<alglib_impl::sparsematrix*>(a.c_ptr()), const_cast<alglib_impl::ae_vector*>(b.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::sparsesolverreport*>(rep.c_ptr()), &_alglib_env_state);
    4893           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4894           0 :     return;
    4895             : }
    4896             : 
    4897             : /*************************************************************************
    4898             : Sparse linear solver for A*x=b with general (nonsymmetric) N*N sparse real
    4899             : matrix A given by its LU factorization, N*1 vectors x and b.
    4900             : 
    4901             : IMPORTANT: this solver requires input matrix  to  be  in  the  CRS  sparse
    4902             :            storage format. An exception will  be  generated  if  you  pass
    4903             :            matrix in some other format (HASH or SKS).
    4904             : 
    4905             : INPUT PARAMETERS
    4906             :     A       -   LU factorization of the sparse matrix, must be NxN exactly
    4907             :                 in CRS storage format
    4908             :     P, Q    -   pivot indexes from LU factorization
    4909             :     N       -   size of A, N>0
    4910             :     B       -   array[0..N-1], right part
    4911             : 
    4912             : OUTPUT PARAMETERS
    4913             :     X       -   array[N], it contains:
    4914             :                 * rep.terminationtype>0    =>  solution
    4915             :                 * rep.terminationtype=-3   =>  filled by zeros
    4916             :     Rep     -   solver report, following fields are set:
    4917             :                 * rep.terminationtype - solver status; >0 for success,
    4918             :                   set to -3 on failure (degenerate system).
    4919             : 
    4920             :   -- ALGLIB --
    4921             :      Copyright 26.12.2017 by Bochkanov Sergey
    4922             : *************************************************************************/
    4923           0 : void sparselusolve(const sparsematrix &a, const integer_1d_array &p, const integer_1d_array &q, const real_1d_array &b, real_1d_array &x, sparsesolverreport &rep, const xparams _xparams)
    4924             : {
    4925             :     jmp_buf _break_jump;
    4926             :     alglib_impl::ae_state _alglib_env_state;
    4927           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    4928           0 :     if( setjmp(_break_jump) )
    4929             :     {
    4930             : #if !defined(AE_NO_EXCEPTIONS)
    4931           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    4932             : #else
    4933             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    4934             :         return;
    4935             : #endif
    4936             :     }
    4937           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    4938           0 :     if( _xparams.flags!=0x0 )
    4939           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    4940           0 :     alglib_impl::sparselusolve(const_cast<alglib_impl::sparsematrix*>(a.c_ptr()), const_cast<alglib_impl::ae_vector*>(p.c_ptr()), const_cast<alglib_impl::ae_vector*>(q.c_ptr()), const_cast<alglib_impl::ae_vector*>(b.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::sparsesolverreport*>(rep.c_ptr()), &_alglib_env_state);
    4941           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    4942           0 :     return;
    4943             : }
    4944             : #endif
    4945             : 
    4946             : #if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
    4947             : /*************************************************************************
    4948             : This object stores state of the linear CG method.
    4949             : 
    4950             : You should use ALGLIB functions to work with this object.
    4951             : Never try to access its fields directly!
    4952             : *************************************************************************/
    4953           0 : _lincgstate_owner::_lincgstate_owner()
    4954             : {
    4955             :     jmp_buf _break_jump;
    4956             :     alglib_impl::ae_state _state;
    4957             :     
    4958           0 :     alglib_impl::ae_state_init(&_state);
    4959           0 :     if( setjmp(_break_jump) )
    4960             :     {
    4961           0 :         if( p_struct!=NULL )
    4962             :         {
    4963           0 :             alglib_impl::_lincgstate_destroy(p_struct);
    4964           0 :             alglib_impl::ae_free(p_struct);
    4965             :         }
    4966           0 :         p_struct = NULL;
    4967             : #if !defined(AE_NO_EXCEPTIONS)
    4968           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    4969             : #else
    4970             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    4971             :         return;
    4972             : #endif
    4973             :     }
    4974           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    4975           0 :     p_struct = NULL;
    4976           0 :     p_struct = (alglib_impl::lincgstate*)alglib_impl::ae_malloc(sizeof(alglib_impl::lincgstate), &_state);
    4977           0 :     memset(p_struct, 0, sizeof(alglib_impl::lincgstate));
    4978           0 :     alglib_impl::_lincgstate_init(p_struct, &_state, ae_false);
    4979           0 :     ae_state_clear(&_state);
    4980           0 : }
    4981             : 
    4982           0 : _lincgstate_owner::_lincgstate_owner(const _lincgstate_owner &rhs)
    4983             : {
    4984             :     jmp_buf _break_jump;
    4985             :     alglib_impl::ae_state _state;
    4986             :     
    4987           0 :     alglib_impl::ae_state_init(&_state);
    4988           0 :     if( setjmp(_break_jump) )
    4989             :     {
    4990           0 :         if( p_struct!=NULL )
    4991             :         {
    4992           0 :             alglib_impl::_lincgstate_destroy(p_struct);
    4993           0 :             alglib_impl::ae_free(p_struct);
    4994             :         }
    4995           0 :         p_struct = NULL;
    4996             : #if !defined(AE_NO_EXCEPTIONS)
    4997           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    4998             : #else
    4999             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    5000             :         return;
    5001             : #endif
    5002             :     }
    5003           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    5004           0 :     p_struct = NULL;
    5005           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: lincgstate copy constructor failure (source is not initialized)", &_state);
    5006           0 :     p_struct = (alglib_impl::lincgstate*)alglib_impl::ae_malloc(sizeof(alglib_impl::lincgstate), &_state);
    5007           0 :     memset(p_struct, 0, sizeof(alglib_impl::lincgstate));
    5008           0 :     alglib_impl::_lincgstate_init_copy(p_struct, const_cast<alglib_impl::lincgstate*>(rhs.p_struct), &_state, ae_false);
    5009           0 :     ae_state_clear(&_state);
    5010           0 : }
    5011             : 
    5012           0 : _lincgstate_owner& _lincgstate_owner::operator=(const _lincgstate_owner &rhs)
    5013             : {
    5014           0 :     if( this==&rhs )
    5015           0 :         return *this;
    5016             :     jmp_buf _break_jump;
    5017             :     alglib_impl::ae_state _state;
    5018             :     
    5019           0 :     alglib_impl::ae_state_init(&_state);
    5020           0 :     if( setjmp(_break_jump) )
    5021             :     {
    5022             : #if !defined(AE_NO_EXCEPTIONS)
    5023           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    5024             : #else
    5025             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    5026             :         return *this;
    5027             : #endif
    5028             :     }
    5029           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    5030           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: lincgstate assignment constructor failure (destination is not initialized)", &_state);
    5031           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: lincgstate assignment constructor failure (source is not initialized)", &_state);
    5032           0 :     alglib_impl::_lincgstate_destroy(p_struct);
    5033           0 :     memset(p_struct, 0, sizeof(alglib_impl::lincgstate));
    5034           0 :     alglib_impl::_lincgstate_init_copy(p_struct, const_cast<alglib_impl::lincgstate*>(rhs.p_struct), &_state, ae_false);
    5035           0 :     ae_state_clear(&_state);
    5036           0 :     return *this;
    5037             : }
    5038             : 
    5039           0 : _lincgstate_owner::~_lincgstate_owner()
    5040             : {
    5041           0 :     if( p_struct!=NULL )
    5042             :     {
    5043           0 :         alglib_impl::_lincgstate_destroy(p_struct);
    5044           0 :         ae_free(p_struct);
    5045             :     }
    5046           0 : }
    5047             : 
    5048           0 : alglib_impl::lincgstate* _lincgstate_owner::c_ptr()
    5049             : {
    5050           0 :     return p_struct;
    5051             : }
    5052             : 
    5053           0 : alglib_impl::lincgstate* _lincgstate_owner::c_ptr() const
    5054             : {
    5055           0 :     return const_cast<alglib_impl::lincgstate*>(p_struct);
    5056             : }
    5057           0 : lincgstate::lincgstate() : _lincgstate_owner() 
    5058             : {
    5059           0 : }
    5060             : 
    5061           0 : lincgstate::lincgstate(const lincgstate &rhs):_lincgstate_owner(rhs) 
    5062             : {
    5063           0 : }
    5064             : 
    5065           0 : lincgstate& lincgstate::operator=(const lincgstate &rhs)
    5066             : {
    5067           0 :     if( this==&rhs )
    5068           0 :         return *this;
    5069           0 :     _lincgstate_owner::operator=(rhs);
    5070           0 :     return *this;
    5071             : }
    5072             : 
    5073           0 : lincgstate::~lincgstate()
    5074             : {
    5075           0 : }
    5076             : 
    5077             : 
    5078             : /*************************************************************************
    5079             : 
    5080             : *************************************************************************/
    5081           0 : _lincgreport_owner::_lincgreport_owner()
    5082             : {
    5083             :     jmp_buf _break_jump;
    5084             :     alglib_impl::ae_state _state;
    5085             :     
    5086           0 :     alglib_impl::ae_state_init(&_state);
    5087           0 :     if( setjmp(_break_jump) )
    5088             :     {
    5089           0 :         if( p_struct!=NULL )
    5090             :         {
    5091           0 :             alglib_impl::_lincgreport_destroy(p_struct);
    5092           0 :             alglib_impl::ae_free(p_struct);
    5093             :         }
    5094           0 :         p_struct = NULL;
    5095             : #if !defined(AE_NO_EXCEPTIONS)
    5096           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    5097             : #else
    5098             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    5099             :         return;
    5100             : #endif
    5101             :     }
    5102           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    5103           0 :     p_struct = NULL;
    5104           0 :     p_struct = (alglib_impl::lincgreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::lincgreport), &_state);
    5105           0 :     memset(p_struct, 0, sizeof(alglib_impl::lincgreport));
    5106           0 :     alglib_impl::_lincgreport_init(p_struct, &_state, ae_false);
    5107           0 :     ae_state_clear(&_state);
    5108           0 : }
    5109             : 
    5110           0 : _lincgreport_owner::_lincgreport_owner(const _lincgreport_owner &rhs)
    5111             : {
    5112             :     jmp_buf _break_jump;
    5113             :     alglib_impl::ae_state _state;
    5114             :     
    5115           0 :     alglib_impl::ae_state_init(&_state);
    5116           0 :     if( setjmp(_break_jump) )
    5117             :     {
    5118           0 :         if( p_struct!=NULL )
    5119             :         {
    5120           0 :             alglib_impl::_lincgreport_destroy(p_struct);
    5121           0 :             alglib_impl::ae_free(p_struct);
    5122             :         }
    5123           0 :         p_struct = NULL;
    5124             : #if !defined(AE_NO_EXCEPTIONS)
    5125           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    5126             : #else
    5127             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    5128             :         return;
    5129             : #endif
    5130             :     }
    5131           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    5132           0 :     p_struct = NULL;
    5133           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: lincgreport copy constructor failure (source is not initialized)", &_state);
    5134           0 :     p_struct = (alglib_impl::lincgreport*)alglib_impl::ae_malloc(sizeof(alglib_impl::lincgreport), &_state);
    5135           0 :     memset(p_struct, 0, sizeof(alglib_impl::lincgreport));
    5136           0 :     alglib_impl::_lincgreport_init_copy(p_struct, const_cast<alglib_impl::lincgreport*>(rhs.p_struct), &_state, ae_false);
    5137           0 :     ae_state_clear(&_state);
    5138           0 : }
    5139             : 
    5140           0 : _lincgreport_owner& _lincgreport_owner::operator=(const _lincgreport_owner &rhs)
    5141             : {
    5142           0 :     if( this==&rhs )
    5143           0 :         return *this;
    5144             :     jmp_buf _break_jump;
    5145             :     alglib_impl::ae_state _state;
    5146             :     
    5147           0 :     alglib_impl::ae_state_init(&_state);
    5148           0 :     if( setjmp(_break_jump) )
    5149             :     {
    5150             : #if !defined(AE_NO_EXCEPTIONS)
    5151           0 :         _ALGLIB_CPP_EXCEPTION(_state.error_msg);
    5152             : #else
    5153             :         _ALGLIB_SET_ERROR_FLAG(_state.error_msg);
    5154             :         return *this;
    5155             : #endif
    5156             :     }
    5157           0 :     alglib_impl::ae_state_set_break_jump(&_state, &_break_jump);
    5158           0 :     alglib_impl::ae_assert(p_struct!=NULL, "ALGLIB: lincgreport assignment constructor failure (destination is not initialized)", &_state);
    5159           0 :     alglib_impl::ae_assert(rhs.p_struct!=NULL, "ALGLIB: lincgreport assignment constructor failure (source is not initialized)", &_state);
    5160           0 :     alglib_impl::_lincgreport_destroy(p_struct);
    5161           0 :     memset(p_struct, 0, sizeof(alglib_impl::lincgreport));
    5162           0 :     alglib_impl::_lincgreport_init_copy(p_struct, const_cast<alglib_impl::lincgreport*>(rhs.p_struct), &_state, ae_false);
    5163           0 :     ae_state_clear(&_state);
    5164           0 :     return *this;
    5165             : }
    5166             : 
    5167           0 : _lincgreport_owner::~_lincgreport_owner()
    5168             : {
    5169           0 :     if( p_struct!=NULL )
    5170             :     {
    5171           0 :         alglib_impl::_lincgreport_destroy(p_struct);
    5172           0 :         ae_free(p_struct);
    5173             :     }
    5174           0 : }
    5175             : 
    5176           0 : alglib_impl::lincgreport* _lincgreport_owner::c_ptr()
    5177             : {
    5178           0 :     return p_struct;
    5179             : }
    5180             : 
    5181           0 : alglib_impl::lincgreport* _lincgreport_owner::c_ptr() const
    5182             : {
    5183           0 :     return const_cast<alglib_impl::lincgreport*>(p_struct);
    5184             : }
    5185           0 : lincgreport::lincgreport() : _lincgreport_owner() ,iterationscount(p_struct->iterationscount),nmv(p_struct->nmv),terminationtype(p_struct->terminationtype),r2(p_struct->r2)
    5186             : {
    5187           0 : }
    5188             : 
    5189           0 : lincgreport::lincgreport(const lincgreport &rhs):_lincgreport_owner(rhs) ,iterationscount(p_struct->iterationscount),nmv(p_struct->nmv),terminationtype(p_struct->terminationtype),r2(p_struct->r2)
    5190             : {
    5191           0 : }
    5192             : 
    5193           0 : lincgreport& lincgreport::operator=(const lincgreport &rhs)
    5194             : {
    5195           0 :     if( this==&rhs )
    5196           0 :         return *this;
    5197           0 :     _lincgreport_owner::operator=(rhs);
    5198           0 :     return *this;
    5199             : }
    5200             : 
    5201           0 : lincgreport::~lincgreport()
    5202             : {
    5203           0 : }
    5204             : 
    5205             : /*************************************************************************
    5206             : This function initializes linear CG Solver. This solver is used  to  solve
    5207             : symmetric positive definite problems. If you want  to  solve  nonsymmetric
    5208             : (or non-positive definite) problem you may use LinLSQR solver provided  by
    5209             : ALGLIB.
    5210             : 
    5211             : USAGE:
    5212             : 1. User initializes algorithm state with LinCGCreate() call
    5213             : 2. User tunes solver parameters with  LinCGSetCond() and other functions
    5214             : 3. Optionally, user sets starting point with LinCGSetStartingPoint()
    5215             : 4. User  calls LinCGSolveSparse() function which takes algorithm state and
    5216             :    SparseMatrix object.
    5217             : 5. User calls LinCGResults() to get solution
    5218             : 6. Optionally, user may call LinCGSolveSparse()  again  to  solve  another
    5219             :    problem  with different matrix and/or right part without reinitializing
    5220             :    LinCGState structure.
    5221             : 
    5222             : INPUT PARAMETERS:
    5223             :     N       -   problem dimension, N>0
    5224             : 
    5225             : OUTPUT PARAMETERS:
    5226             :     State   -   structure which stores algorithm state
    5227             : 
    5228             :   -- ALGLIB --
    5229             :      Copyright 14.11.2011 by Bochkanov Sergey
    5230             : *************************************************************************/
    5231           0 : void lincgcreate(const ae_int_t n, lincgstate &state, const xparams _xparams)
    5232             : {
    5233             :     jmp_buf _break_jump;
    5234             :     alglib_impl::ae_state _alglib_env_state;
    5235           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5236           0 :     if( setjmp(_break_jump) )
    5237             :     {
    5238             : #if !defined(AE_NO_EXCEPTIONS)
    5239           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5240             : #else
    5241             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5242             :         return;
    5243             : #endif
    5244             :     }
    5245           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5246           0 :     if( _xparams.flags!=0x0 )
    5247           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5248           0 :     alglib_impl::lincgcreate(n, const_cast<alglib_impl::lincgstate*>(state.c_ptr()), &_alglib_env_state);
    5249           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5250           0 :     return;
    5251             : }
    5252             : 
    5253             : /*************************************************************************
    5254             : This function sets starting point.
    5255             : By default, zero starting point is used.
    5256             : 
    5257             : INPUT PARAMETERS:
    5258             :     X       -   starting point, array[N]
    5259             : 
    5260             : OUTPUT PARAMETERS:
    5261             :     State   -   structure which stores algorithm state
    5262             : 
    5263             :   -- ALGLIB --
    5264             :      Copyright 14.11.2011 by Bochkanov Sergey
    5265             : *************************************************************************/
    5266           0 : void lincgsetstartingpoint(const lincgstate &state, const real_1d_array &x, const xparams _xparams)
    5267             : {
    5268             :     jmp_buf _break_jump;
    5269             :     alglib_impl::ae_state _alglib_env_state;
    5270           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5271           0 :     if( setjmp(_break_jump) )
    5272             :     {
    5273             : #if !defined(AE_NO_EXCEPTIONS)
    5274           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5275             : #else
    5276             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5277             :         return;
    5278             : #endif
    5279             :     }
    5280           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5281           0 :     if( _xparams.flags!=0x0 )
    5282           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5283           0 :     alglib_impl::lincgsetstartingpoint(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), &_alglib_env_state);
    5284           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5285           0 :     return;
    5286             : }
    5287             : 
    5288             : /*************************************************************************
    5289             : This  function  changes  preconditioning  settings  of  LinCGSolveSparse()
    5290             : function. By default, SolveSparse() uses diagonal preconditioner,  but  if
    5291             : you want to use solver without preconditioning, you can call this function
    5292             : which forces solver to use unit matrix for preconditioning.
    5293             : 
    5294             : INPUT PARAMETERS:
    5295             :     State   -   structure which stores algorithm state
    5296             : 
    5297             :   -- ALGLIB --
    5298             :      Copyright 19.11.2012 by Bochkanov Sergey
    5299             : *************************************************************************/
    5300           0 : void lincgsetprecunit(const lincgstate &state, const xparams _xparams)
    5301             : {
    5302             :     jmp_buf _break_jump;
    5303             :     alglib_impl::ae_state _alglib_env_state;
    5304           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5305           0 :     if( setjmp(_break_jump) )
    5306             :     {
    5307             : #if !defined(AE_NO_EXCEPTIONS)
    5308           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5309             : #else
    5310             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5311             :         return;
    5312             : #endif
    5313             :     }
    5314           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5315           0 :     if( _xparams.flags!=0x0 )
    5316           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5317           0 :     alglib_impl::lincgsetprecunit(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), &_alglib_env_state);
    5318           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5319           0 :     return;
    5320             : }
    5321             : 
    5322             : /*************************************************************************
    5323             : This  function  changes  preconditioning  settings  of  LinCGSolveSparse()
    5324             : function.  LinCGSolveSparse() will use diagonal of the  system  matrix  as
    5325             : preconditioner. This preconditioning mode is active by default.
    5326             : 
    5327             : INPUT PARAMETERS:
    5328             :     State   -   structure which stores algorithm state
    5329             : 
    5330             :   -- ALGLIB --
    5331             :      Copyright 19.11.2012 by Bochkanov Sergey
    5332             : *************************************************************************/
    5333           0 : void lincgsetprecdiag(const lincgstate &state, const xparams _xparams)
    5334             : {
    5335             :     jmp_buf _break_jump;
    5336             :     alglib_impl::ae_state _alglib_env_state;
    5337           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5338           0 :     if( setjmp(_break_jump) )
    5339             :     {
    5340             : #if !defined(AE_NO_EXCEPTIONS)
    5341           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5342             : #else
    5343             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5344             :         return;
    5345             : #endif
    5346             :     }
    5347           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5348           0 :     if( _xparams.flags!=0x0 )
    5349           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5350           0 :     alglib_impl::lincgsetprecdiag(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), &_alglib_env_state);
    5351           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5352           0 :     return;
    5353             : }
    5354             : 
    5355             : /*************************************************************************
    5356             : This function sets stopping criteria.
    5357             : 
    5358             : INPUT PARAMETERS:
    5359             :     EpsF    -   algorithm will be stopped if norm of residual is less than
    5360             :                 EpsF*||b||.
    5361             :     MaxIts  -   algorithm will be stopped if number of iterations is  more
    5362             :                 than MaxIts.
    5363             : 
    5364             : OUTPUT PARAMETERS:
    5365             :     State   -   structure which stores algorithm state
    5366             : 
    5367             : NOTES:
    5368             : If  both  EpsF  and  MaxIts  are  zero then small EpsF will be set to small
    5369             : value.
    5370             : 
    5371             :   -- ALGLIB --
    5372             :      Copyright 14.11.2011 by Bochkanov Sergey
    5373             : *************************************************************************/
    5374           0 : void lincgsetcond(const lincgstate &state, const double epsf, const ae_int_t maxits, const xparams _xparams)
    5375             : {
    5376             :     jmp_buf _break_jump;
    5377             :     alglib_impl::ae_state _alglib_env_state;
    5378           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5379           0 :     if( setjmp(_break_jump) )
    5380             :     {
    5381             : #if !defined(AE_NO_EXCEPTIONS)
    5382           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5383             : #else
    5384             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5385             :         return;
    5386             : #endif
    5387             :     }
    5388           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5389           0 :     if( _xparams.flags!=0x0 )
    5390           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5391           0 :     alglib_impl::lincgsetcond(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), epsf, maxits, &_alglib_env_state);
    5392           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5393           0 :     return;
    5394             : }
    5395             : 
    5396             : /*************************************************************************
    5397             : Procedure for solution of A*x=b with sparse A.
    5398             : 
    5399             : INPUT PARAMETERS:
    5400             :     State   -   algorithm state
    5401             :     A       -   sparse matrix in the CRS format (you MUST contvert  it  to
    5402             :                 CRS format by calling SparseConvertToCRS() function).
    5403             :     IsUpper -   whether upper or lower triangle of A is used:
    5404             :                 * IsUpper=True  => only upper triangle is used and lower
    5405             :                                    triangle is not referenced at all
    5406             :                 * IsUpper=False => only lower triangle is used and upper
    5407             :                                    triangle is not referenced at all
    5408             :     B       -   right part, array[N]
    5409             : 
    5410             : RESULT:
    5411             :     This function returns no result.
    5412             :     You can get solution by calling LinCGResults()
    5413             : 
    5414             : NOTE: this function uses lightweight preconditioning -  multiplication  by
    5415             :       inverse of diag(A). If you want, you can turn preconditioning off by
    5416             :       calling LinCGSetPrecUnit(). However, preconditioning cost is low and
    5417             :       preconditioner  is  very  important  for  solution  of  badly scaled
    5418             :       problems.
    5419             : 
    5420             :   -- ALGLIB --
    5421             :      Copyright 14.11.2011 by Bochkanov Sergey
    5422             : *************************************************************************/
    5423           0 : void lincgsolvesparse(const lincgstate &state, const sparsematrix &a, const bool isupper, const real_1d_array &b, const xparams _xparams)
    5424             : {
    5425             :     jmp_buf _break_jump;
    5426             :     alglib_impl::ae_state _alglib_env_state;
    5427           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5428           0 :     if( setjmp(_break_jump) )
    5429             :     {
    5430             : #if !defined(AE_NO_EXCEPTIONS)
    5431           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5432             : #else
    5433             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5434             :         return;
    5435             : #endif
    5436             :     }
    5437           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5438           0 :     if( _xparams.flags!=0x0 )
    5439           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5440           0 :     alglib_impl::lincgsolvesparse(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), const_cast<alglib_impl::sparsematrix*>(a.c_ptr()), isupper, const_cast<alglib_impl::ae_vector*>(b.c_ptr()), &_alglib_env_state);
    5441           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5442           0 :     return;
    5443             : }
    5444             : 
    5445             : /*************************************************************************
    5446             : CG-solver: results.
    5447             : 
    5448             : This function must be called after LinCGSolve
    5449             : 
    5450             : INPUT PARAMETERS:
    5451             :     State   -   algorithm state
    5452             : 
    5453             : OUTPUT PARAMETERS:
    5454             :     X       -   array[N], solution
    5455             :     Rep     -   optimization report:
    5456             :                 * Rep.TerminationType completetion code:
    5457             :                     * -5    input matrix is either not positive definite,
    5458             :                             too large or too small
    5459             :                     * -4    overflow/underflow during solution
    5460             :                             (ill conditioned problem)
    5461             :                     *  1    ||residual||<=EpsF*||b||
    5462             :                     *  5    MaxIts steps was taken
    5463             :                     *  7    rounding errors prevent further progress,
    5464             :                             best point found is returned
    5465             :                 * Rep.IterationsCount contains iterations count
    5466             :                 * NMV countains number of matrix-vector calculations
    5467             : 
    5468             :   -- ALGLIB --
    5469             :      Copyright 14.11.2011 by Bochkanov Sergey
    5470             : *************************************************************************/
    5471           0 : void lincgresults(const lincgstate &state, real_1d_array &x, lincgreport &rep, const xparams _xparams)
    5472             : {
    5473             :     jmp_buf _break_jump;
    5474             :     alglib_impl::ae_state _alglib_env_state;
    5475           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5476           0 :     if( setjmp(_break_jump) )
    5477             :     {
    5478             : #if !defined(AE_NO_EXCEPTIONS)
    5479           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5480             : #else
    5481             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5482             :         return;
    5483             : #endif
    5484             :     }
    5485           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5486           0 :     if( _xparams.flags!=0x0 )
    5487           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5488           0 :     alglib_impl::lincgresults(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), const_cast<alglib_impl::ae_vector*>(x.c_ptr()), const_cast<alglib_impl::lincgreport*>(rep.c_ptr()), &_alglib_env_state);
    5489           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5490           0 :     return;
    5491             : }
    5492             : 
    5493             : /*************************************************************************
    5494             : This function sets restart frequency. By default, algorithm  is  restarted
    5495             : after N subsequent iterations.
    5496             : 
    5497             :   -- ALGLIB --
    5498             :      Copyright 14.11.2011 by Bochkanov Sergey
    5499             : *************************************************************************/
    5500           0 : void lincgsetrestartfreq(const lincgstate &state, const ae_int_t srf, const xparams _xparams)
    5501             : {
    5502             :     jmp_buf _break_jump;
    5503             :     alglib_impl::ae_state _alglib_env_state;
    5504           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5505           0 :     if( setjmp(_break_jump) )
    5506             :     {
    5507             : #if !defined(AE_NO_EXCEPTIONS)
    5508           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5509             : #else
    5510             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5511             :         return;
    5512             : #endif
    5513             :     }
    5514           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5515           0 :     if( _xparams.flags!=0x0 )
    5516           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5517           0 :     alglib_impl::lincgsetrestartfreq(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), srf, &_alglib_env_state);
    5518           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5519           0 :     return;
    5520             : }
    5521             : 
    5522             : /*************************************************************************
    5523             : This function sets frequency of residual recalculations.
    5524             : 
    5525             : Algorithm updates residual r_k using iterative formula,  but  recalculates
    5526             : it from scratch after each 10 iterations. It is done to avoid accumulation
    5527             : of numerical errors and to stop algorithm when r_k starts to grow.
    5528             : 
    5529             : Such low update frequence (1/10) gives very  little  overhead,  but  makes
    5530             : algorithm a bit more robust against numerical errors. However, you may
    5531             : change it
    5532             : 
    5533             : INPUT PARAMETERS:
    5534             :     Freq    -   desired update frequency, Freq>=0.
    5535             :                 Zero value means that no updates will be done.
    5536             : 
    5537             :   -- ALGLIB --
    5538             :      Copyright 14.11.2011 by Bochkanov Sergey
    5539             : *************************************************************************/
    5540           0 : void lincgsetrupdatefreq(const lincgstate &state, const ae_int_t freq, const xparams _xparams)
    5541             : {
    5542             :     jmp_buf _break_jump;
    5543             :     alglib_impl::ae_state _alglib_env_state;
    5544           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5545           0 :     if( setjmp(_break_jump) )
    5546             :     {
    5547             : #if !defined(AE_NO_EXCEPTIONS)
    5548           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5549             : #else
    5550             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5551             :         return;
    5552             : #endif
    5553             :     }
    5554           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5555           0 :     if( _xparams.flags!=0x0 )
    5556           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5557           0 :     alglib_impl::lincgsetrupdatefreq(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), freq, &_alglib_env_state);
    5558           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5559           0 :     return;
    5560             : }
    5561             : 
    5562             : /*************************************************************************
    5563             : This function turns on/off reporting.
    5564             : 
    5565             : INPUT PARAMETERS:
    5566             :     State   -   structure which stores algorithm state
    5567             :     NeedXRep-   whether iteration reports are needed or not
    5568             : 
    5569             : If NeedXRep is True, algorithm will call rep() callback function if  it is
    5570             : provided to MinCGOptimize().
    5571             : 
    5572             :   -- ALGLIB --
    5573             :      Copyright 14.11.2011 by Bochkanov Sergey
    5574             : *************************************************************************/
    5575           0 : void lincgsetxrep(const lincgstate &state, const bool needxrep, const xparams _xparams)
    5576             : {
    5577             :     jmp_buf _break_jump;
    5578             :     alglib_impl::ae_state _alglib_env_state;
    5579           0 :     alglib_impl::ae_state_init(&_alglib_env_state);
    5580           0 :     if( setjmp(_break_jump) )
    5581             :     {
    5582             : #if !defined(AE_NO_EXCEPTIONS)
    5583           0 :         _ALGLIB_CPP_EXCEPTION(_alglib_env_state.error_msg);
    5584             : #else
    5585             :         _ALGLIB_SET_ERROR_FLAG(_alglib_env_state.error_msg);
    5586             :         return;
    5587             : #endif
    5588             :     }
    5589           0 :     ae_state_set_break_jump(&_alglib_env_state, &_break_jump);
    5590           0 :     if( _xparams.flags!=0x0 )
    5591           0 :         ae_state_set_flags(&_alglib_env_state, _xparams.flags);
    5592           0 :     alglib_impl::lincgsetxrep(const_cast<alglib_impl::lincgstate*>(state.c_ptr()), needxrep, &_alglib_env_state);
    5593           0 :     alglib_impl::ae_state_clear(&_alglib_env_state);
    5594           0 :     return;
    5595             : }
    5596             : #endif
    5597             : }
    5598             : 
    5599             : /////////////////////////////////////////////////////////////////////////
    5600             : //
    5601             : // THIS SECTION CONTAINS IMPLEMENTATION OF COMPUTATIONAL CORE
    5602             : //
    5603             : /////////////////////////////////////////////////////////////////////////
    5604             : namespace alglib_impl
    5605             : {
    5606             : #if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
    5607             : static void directdensesolvers_rmatrixlusolveinternal(/* Real    */ ae_matrix* lua,
    5608             :      /* Integer */ ae_vector* p,
    5609             :      ae_int_t n,
    5610             :      /* Real    */ ae_matrix* a,
    5611             :      ae_bool havea,
    5612             :      /* Real    */ ae_matrix* b,
    5613             :      ae_int_t m,
    5614             :      ae_int_t* info,
    5615             :      densesolverreport* rep,
    5616             :      /* Real    */ ae_matrix* x,
    5617             :      ae_state *_state);
    5618             : static void directdensesolvers_spdmatrixcholeskysolveinternal(/* Real    */ ae_matrix* cha,
    5619             :      ae_int_t n,
    5620             :      ae_bool isupper,
    5621             :      /* Real    */ ae_matrix* a,
    5622             :      ae_bool havea,
    5623             :      /* Real    */ ae_matrix* b,
    5624             :      ae_int_t m,
    5625             :      ae_int_t* info,
    5626             :      densesolverreport* rep,
    5627             :      /* Real    */ ae_matrix* x,
    5628             :      ae_state *_state);
    5629             : static void directdensesolvers_cmatrixlusolveinternal(/* Complex */ ae_matrix* lua,
    5630             :      /* Integer */ ae_vector* p,
    5631             :      ae_int_t n,
    5632             :      /* Complex */ ae_matrix* a,
    5633             :      ae_bool havea,
    5634             :      /* Complex */ ae_matrix* b,
    5635             :      ae_int_t m,
    5636             :      ae_int_t* info,
    5637             :      densesolverreport* rep,
    5638             :      /* Complex */ ae_matrix* x,
    5639             :      ae_state *_state);
    5640             : static void directdensesolvers_hpdmatrixcholeskysolveinternal(/* Complex */ ae_matrix* cha,
    5641             :      ae_int_t n,
    5642             :      ae_bool isupper,
    5643             :      /* Complex */ ae_matrix* a,
    5644             :      ae_bool havea,
    5645             :      /* Complex */ ae_matrix* b,
    5646             :      ae_int_t m,
    5647             :      ae_int_t* info,
    5648             :      densesolverreport* rep,
    5649             :      /* Complex */ ae_matrix* x,
    5650             :      ae_state *_state);
    5651             : static ae_int_t directdensesolvers_densesolverrfsmax(ae_int_t n,
    5652             :      double r1,
    5653             :      double rinf,
    5654             :      ae_state *_state);
    5655             : static ae_int_t directdensesolvers_densesolverrfsmaxv2(ae_int_t n,
    5656             :      double r2,
    5657             :      ae_state *_state);
    5658             : static void directdensesolvers_rbasiclusolve(/* Real    */ ae_matrix* lua,
    5659             :      /* Integer */ ae_vector* p,
    5660             :      ae_int_t n,
    5661             :      /* Real    */ ae_vector* xb,
    5662             :      ae_state *_state);
    5663             : static void directdensesolvers_spdbasiccholeskysolve(/* Real    */ ae_matrix* cha,
    5664             :      ae_int_t n,
    5665             :      ae_bool isupper,
    5666             :      /* Real    */ ae_vector* xb,
    5667             :      ae_state *_state);
    5668             : static void directdensesolvers_cbasiclusolve(/* Complex */ ae_matrix* lua,
    5669             :      /* Integer */ ae_vector* p,
    5670             :      ae_int_t n,
    5671             :      /* Complex */ ae_vector* xb,
    5672             :      ae_state *_state);
    5673             : static void directdensesolvers_hpdbasiccholeskysolve(/* Complex */ ae_matrix* cha,
    5674             :      ae_int_t n,
    5675             :      ae_bool isupper,
    5676             :      /* Complex */ ae_vector* xb,
    5677             :      ae_state *_state);
    5678             : 
    5679             : 
    5680             : #endif
    5681             : #if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
    5682             : static double linlsqr_atol = 1.0E-6;
    5683             : static double linlsqr_btol = 1.0E-6;
    5684             : static void linlsqr_clearrfields(linlsqrstate* state, ae_state *_state);
    5685             : 
    5686             : 
    5687             : #endif
    5688             : #if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
    5689             : 
    5690             : 
    5691             : #endif
    5692             : #if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
    5693             : static void nleq_clearrequestfields(nleqstate* state, ae_state *_state);
    5694             : static ae_bool nleq_increaselambda(double* lambdav,
    5695             :      double* nu,
    5696             :      double lambdaup,
    5697             :      ae_state *_state);
    5698             : static void nleq_decreaselambda(double* lambdav,
    5699             :      double* nu,
    5700             :      double lambdadown,
    5701             :      ae_state *_state);
    5702             : 
    5703             : 
    5704             : #endif
    5705             : #if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
    5706             : static void directsparsesolvers_initreport(sparsesolverreport* rep,
    5707             :      ae_state *_state);
    5708             : 
    5709             : 
    5710             : #endif
    5711             : #if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
    5712             : static double lincg_defaultprecision = 1.0E-6;
    5713             : static void lincg_clearrfields(lincgstate* state, ae_state *_state);
    5714             : static void lincg_updateitersdata(lincgstate* state, ae_state *_state);
    5715             : 
    5716             : 
    5717             : #endif
    5718             : 
    5719             : #if defined(AE_COMPILE_DIRECTDENSESOLVERS) || !defined(AE_PARTIAL_BUILD)
    5720             : 
    5721             : 
    5722             : /*************************************************************************
    5723             : Dense solver for A*x=b with N*N real matrix A and N*1 real vectorx  x  and
    5724             : b. This is "slow-but-feature rich" version of the  linear  solver.  Faster
    5725             : version is RMatrixSolveFast() function.
    5726             : 
    5727             : Algorithm features:
    5728             : * automatic detection of degenerate cases
    5729             : * condition number estimation
    5730             : * iterative refinement
    5731             : * O(N^3) complexity
    5732             : 
    5733             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    5734             :            ! by ALGLIB. It estimates condition  number  of  linear  system
    5735             :            ! and  performs  iterative   refinement,   which   results   in
    5736             :            ! significant performance penalty  when  compared  with  "fast"
    5737             :            ! version  which  just  performs  LU  decomposition  and  calls
    5738             :            ! triangular solver.
    5739             :            !
    5740             :            ! This  performance  penalty  is  especially  visible  in   the
    5741             :            ! multithreaded mode, because both condition number  estimation
    5742             :            ! and   iterative    refinement   are   inherently   sequential
    5743             :            ! calculations. It is also very significant on small matrices.
    5744             :            !
    5745             :            ! Thus, if you need high performance and if you are pretty sure
    5746             :            ! that your system is well conditioned, we  strongly  recommend
    5747             :            ! you to use faster solver, RMatrixSolveFast() function.
    5748             : 
    5749             :   ! COMMERCIAL EDITION OF ALGLIB:
    5750             :   ! 
    5751             :   ! Commercial Edition of ALGLIB includes following important improvements
    5752             :   ! of this function:
    5753             :   ! * high-performance native backend with same C# interface (C# version)
    5754             :   ! * multithreading support (C++ and C# versions)
    5755             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    5756             :   !   (C++ and C# versions, x86/x64 platform)
    5757             :   ! 
    5758             :   ! We recommend you to read 'Working with commercial version' section  of
    5759             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    5760             :   ! related features provided by commercial edition of ALGLIB.
    5761             : 
    5762             : INPUT PARAMETERS
    5763             :     A       -   array[0..N-1,0..N-1], system matrix
    5764             :     N       -   size of A
    5765             :     B       -   array[0..N-1], right part
    5766             : 
    5767             : OUTPUT PARAMETERS
    5768             :     Info    -   return code:
    5769             :                 * -3    matrix is very badly conditioned or exactly singular.
    5770             :                 * -1    N<=0 was passed
    5771             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    5772             :                         check R1/RInf parameters for condition numbers).
    5773             :     Rep     -   additional report, following fields are set:
    5774             :                 * rep.r1    condition number in 1-norm
    5775             :                 * rep.rinf  condition number in inf-norm
    5776             :     X       -   array[N], it contains:
    5777             :                 * info>0    =>  solution
    5778             :                 * info=-3   =>  filled by zeros
    5779             : 
    5780             :   -- ALGLIB --
    5781             :      Copyright 27.01.2010 by Bochkanov Sergey
    5782             : *************************************************************************/
    5783           0 : void rmatrixsolve(/* Real    */ ae_matrix* a,
    5784             :      ae_int_t n,
    5785             :      /* Real    */ ae_vector* b,
    5786             :      ae_int_t* info,
    5787             :      densesolverreport* rep,
    5788             :      /* Real    */ ae_vector* x,
    5789             :      ae_state *_state)
    5790             : {
    5791             :     ae_frame _frame_block;
    5792             :     ae_matrix bm;
    5793             :     ae_matrix xm;
    5794             : 
    5795           0 :     ae_frame_make(_state, &_frame_block);
    5796           0 :     memset(&bm, 0, sizeof(bm));
    5797           0 :     memset(&xm, 0, sizeof(xm));
    5798           0 :     *info = 0;
    5799           0 :     _densesolverreport_clear(rep);
    5800           0 :     ae_vector_clear(x);
    5801           0 :     ae_matrix_init(&bm, 0, 0, DT_REAL, _state, ae_true);
    5802           0 :     ae_matrix_init(&xm, 0, 0, DT_REAL, _state, ae_true);
    5803             : 
    5804           0 :     if( n<=0 )
    5805             :     {
    5806           0 :         *info = -1;
    5807           0 :         ae_frame_leave(_state);
    5808           0 :         return;
    5809             :     }
    5810           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    5811           0 :     ae_v_move(&bm.ptr.pp_double[0][0], bm.stride, &b->ptr.p_double[0], 1, ae_v_len(0,n-1));
    5812           0 :     rmatrixsolvem(a, n, &bm, 1, ae_true, info, rep, &xm, _state);
    5813           0 :     ae_vector_set_length(x, n, _state);
    5814           0 :     ae_v_move(&x->ptr.p_double[0], 1, &xm.ptr.pp_double[0][0], xm.stride, ae_v_len(0,n-1));
    5815           0 :     ae_frame_leave(_state);
    5816             : }
    5817             : 
    5818             : 
    5819             : /*************************************************************************
    5820             : Dense solver.
    5821             : 
    5822             : This  subroutine  solves  a  system  A*x=b,  where A is NxN non-denegerate
    5823             : real matrix, x  and  b  are  vectors.  This is a "fast" version of  linear
    5824             : solver which does NOT provide  any  additional  functions  like  condition
    5825             : number estimation or iterative refinement.
    5826             : 
    5827             : Algorithm features:
    5828             : * efficient algorithm O(N^3) complexity
    5829             : * no performance overhead from additional functionality
    5830             : 
    5831             : If you need condition number estimation or iterative refinement, use  more
    5832             : feature-rich version - RMatrixSolve().
    5833             : 
    5834             :   ! COMMERCIAL EDITION OF ALGLIB:
    5835             :   ! 
    5836             :   ! Commercial Edition of ALGLIB includes following important improvements
    5837             :   ! of this function:
    5838             :   ! * high-performance native backend with same C# interface (C# version)
    5839             :   ! * multithreading support (C++ and C# versions)
    5840             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    5841             :   !   (C++ and C# versions, x86/x64 platform)
    5842             :   ! 
    5843             :   ! We recommend you to read 'Working with commercial version' section  of
    5844             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    5845             :   ! related features provided by commercial edition of ALGLIB.
    5846             : 
    5847             : INPUT PARAMETERS
    5848             :     A       -   array[0..N-1,0..N-1], system matrix
    5849             :     N       -   size of A
    5850             :     B       -   array[0..N-1], right part
    5851             : 
    5852             : OUTPUT PARAMETERS
    5853             :     Info    -   return code:
    5854             :                 * -3    matrix is exactly singular (ill conditioned matrices
    5855             :                         are not recognized).
    5856             :                 * -1    N<=0 was passed
    5857             :                 *  1    task is solved 
    5858             :     B       -   array[N]:
    5859             :                 * info>0    =>  overwritten by solution
    5860             :                 * info=-3   =>  filled by zeros
    5861             : 
    5862             :   -- ALGLIB --
    5863             :      Copyright 16.03.2015 by Bochkanov Sergey
    5864             : *************************************************************************/
    5865           0 : void rmatrixsolvefast(/* Real    */ ae_matrix* a,
    5866             :      ae_int_t n,
    5867             :      /* Real    */ ae_vector* b,
    5868             :      ae_int_t* info,
    5869             :      ae_state *_state)
    5870             : {
    5871             :     ae_frame _frame_block;
    5872             :     ae_matrix _a;
    5873             :     ae_int_t i;
    5874             :     ae_int_t j;
    5875             :     ae_vector p;
    5876             : 
    5877           0 :     ae_frame_make(_state, &_frame_block);
    5878           0 :     memset(&_a, 0, sizeof(_a));
    5879           0 :     memset(&p, 0, sizeof(p));
    5880           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    5881           0 :     a = &_a;
    5882           0 :     *info = 0;
    5883           0 :     ae_vector_init(&p, 0, DT_INT, _state, ae_true);
    5884             : 
    5885           0 :     if( n<=0 )
    5886             :     {
    5887           0 :         *info = -1;
    5888           0 :         ae_frame_leave(_state);
    5889           0 :         return;
    5890             :     }
    5891           0 :     rmatrixlu(a, n, n, &p, _state);
    5892           0 :     for(i=0; i<=n-1; i++)
    5893             :     {
    5894           0 :         if( ae_fp_eq(a->ptr.pp_double[i][i],(double)(0)) )
    5895             :         {
    5896           0 :             for(j=0; j<=n-1; j++)
    5897             :             {
    5898           0 :                 b->ptr.p_double[j] = 0.0;
    5899             :             }
    5900           0 :             *info = -3;
    5901           0 :             ae_frame_leave(_state);
    5902           0 :             return;
    5903             :         }
    5904             :     }
    5905           0 :     directdensesolvers_rbasiclusolve(a, &p, n, b, _state);
    5906           0 :     *info = 1;
    5907           0 :     ae_frame_leave(_state);
    5908             : }
    5909             : 
    5910             : 
    5911             : /*************************************************************************
    5912             : Dense solver.
    5913             : 
    5914             : Similar to RMatrixSolve() but solves task with multiple right parts (where
    5915             : b and x are NxM matrices). This is  "slow-but-robust"  version  of  linear
    5916             : solver with additional functionality  like  condition  number  estimation.
    5917             : There also exists faster version - RMatrixSolveMFast().
    5918             : 
    5919             : Algorithm features:
    5920             : * automatic detection of degenerate cases
    5921             : * condition number estimation
    5922             : * optional iterative refinement
    5923             : * O(N^3+M*N^2) complexity
    5924             : 
    5925             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    5926             :            ! by ALGLIB. It estimates condition  number  of  linear  system
    5927             :            ! and  performs  iterative   refinement,   which   results   in
    5928             :            ! significant performance penalty  when  compared  with  "fast"
    5929             :            ! version  which  just  performs  LU  decomposition  and  calls
    5930             :            ! triangular solver.
    5931             :            !
    5932             :            ! This  performance  penalty  is  especially  visible  in   the
    5933             :            ! multithreaded mode, because both condition number  estimation
    5934             :            ! and   iterative    refinement   are   inherently   sequential
    5935             :            ! calculations. It also very significant on small matrices.
    5936             :            !
    5937             :            ! Thus, if you need high performance and if you are pretty sure
    5938             :            ! that your system is well conditioned, we  strongly  recommend
    5939             :            ! you to use faster solver, RMatrixSolveMFast() function.
    5940             : 
    5941             :   ! COMMERCIAL EDITION OF ALGLIB:
    5942             :   ! 
    5943             :   ! Commercial Edition of ALGLIB includes following important improvements
    5944             :   ! of this function:
    5945             :   ! * high-performance native backend with same C# interface (C# version)
    5946             :   ! * multithreading support (C++ and C# versions)
    5947             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    5948             :   !   (C++ and C# versions, x86/x64 platform)
    5949             :   ! 
    5950             :   ! We recommend you to read 'Working with commercial version' section  of
    5951             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    5952             :   ! related features provided by commercial edition of ALGLIB.
    5953             : 
    5954             : INPUT PARAMETERS
    5955             :     A       -   array[0..N-1,0..N-1], system matrix
    5956             :     N       -   size of A
    5957             :     B       -   array[0..N-1,0..M-1], right part
    5958             :     M       -   right part size
    5959             :     RFS     -   iterative refinement switch:
    5960             :                 * True - refinement is used.
    5961             :                   Less performance, more precision.
    5962             :                 * False - refinement is not used.
    5963             :                   More performance, less precision.
    5964             : 
    5965             : OUTPUT PARAMETERS
    5966             :     Info    -   return code:
    5967             :                 * -3    A is ill conditioned or singular.
    5968             :                         X is filled by zeros in such cases.
    5969             :                 * -1    N<=0 was passed
    5970             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    5971             :                         check R1/RInf parameters for condition numbers).
    5972             :     Rep     -   additional report, following fields are set:
    5973             :                 * rep.r1    condition number in 1-norm
    5974             :                 * rep.rinf  condition number in inf-norm
    5975             :     X       -   array[N], it contains:
    5976             :                 * info>0    =>  solution
    5977             :                 * info=-3   =>  filled by zeros
    5978             : 
    5979             : 
    5980             :   -- ALGLIB --
    5981             :      Copyright 27.01.2010 by Bochkanov Sergey
    5982             : *************************************************************************/
    5983           0 : void rmatrixsolvem(/* Real    */ ae_matrix* a,
    5984             :      ae_int_t n,
    5985             :      /* Real    */ ae_matrix* b,
    5986             :      ae_int_t m,
    5987             :      ae_bool rfs,
    5988             :      ae_int_t* info,
    5989             :      densesolverreport* rep,
    5990             :      /* Real    */ ae_matrix* x,
    5991             :      ae_state *_state)
    5992             : {
    5993             :     ae_frame _frame_block;
    5994             :     ae_matrix da;
    5995             :     ae_matrix emptya;
    5996             :     ae_vector p;
    5997             :     ae_int_t i;
    5998             : 
    5999           0 :     ae_frame_make(_state, &_frame_block);
    6000           0 :     memset(&da, 0, sizeof(da));
    6001           0 :     memset(&emptya, 0, sizeof(emptya));
    6002           0 :     memset(&p, 0, sizeof(p));
    6003           0 :     *info = 0;
    6004           0 :     _densesolverreport_clear(rep);
    6005           0 :     ae_matrix_clear(x);
    6006           0 :     ae_matrix_init(&da, 0, 0, DT_REAL, _state, ae_true);
    6007           0 :     ae_matrix_init(&emptya, 0, 0, DT_REAL, _state, ae_true);
    6008           0 :     ae_vector_init(&p, 0, DT_INT, _state, ae_true);
    6009             : 
    6010             :     
    6011             :     /*
    6012             :      * prepare: check inputs, allocate space...
    6013             :      */
    6014           0 :     if( n<=0||m<=0 )
    6015             :     {
    6016           0 :         *info = -1;
    6017           0 :         ae_frame_leave(_state);
    6018           0 :         return;
    6019             :     }
    6020           0 :     ae_matrix_set_length(&da, n, n, _state);
    6021             :     
    6022             :     /*
    6023             :      * 1. factorize matrix
    6024             :      * 3. solve
    6025             :      */
    6026           0 :     for(i=0; i<=n-1; i++)
    6027             :     {
    6028           0 :         ae_v_move(&da.ptr.pp_double[i][0], 1, &a->ptr.pp_double[i][0], 1, ae_v_len(0,n-1));
    6029             :     }
    6030           0 :     rmatrixlu(&da, n, n, &p, _state);
    6031           0 :     if( rfs )
    6032             :     {
    6033           0 :         directdensesolvers_rmatrixlusolveinternal(&da, &p, n, a, ae_true, b, m, info, rep, x, _state);
    6034             :     }
    6035             :     else
    6036             :     {
    6037           0 :         directdensesolvers_rmatrixlusolveinternal(&da, &p, n, &emptya, ae_false, b, m, info, rep, x, _state);
    6038             :     }
    6039           0 :     ae_frame_leave(_state);
    6040             : }
    6041             : 
    6042             : 
    6043             : /*************************************************************************
    6044             : Dense solver.
    6045             : 
    6046             : Similar to RMatrixSolve() but solves task with multiple right parts (where
    6047             : b and x are NxM matrices). This is "fast" version of linear  solver  which
    6048             : does NOT offer additional functions like condition  number  estimation  or
    6049             : iterative refinement.
    6050             : 
    6051             : Algorithm features:
    6052             : * O(N^3+M*N^2) complexity
    6053             : * no additional functionality, highest performance
    6054             : 
    6055             :   ! COMMERCIAL EDITION OF ALGLIB:
    6056             :   ! 
    6057             :   ! Commercial Edition of ALGLIB includes following important improvements
    6058             :   ! of this function:
    6059             :   ! * high-performance native backend with same C# interface (C# version)
    6060             :   ! * multithreading support (C++ and C# versions)
    6061             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    6062             :   !   (C++ and C# versions, x86/x64 platform)
    6063             :   ! 
    6064             :   ! We recommend you to read 'Working with commercial version' section  of
    6065             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    6066             :   ! related features provided by commercial edition of ALGLIB.
    6067             : 
    6068             : INPUT PARAMETERS
    6069             :     A       -   array[0..N-1,0..N-1], system matrix
    6070             :     N       -   size of A
    6071             :     B       -   array[0..N-1,0..M-1], right part
    6072             :     M       -   right part size
    6073             :     RFS     -   iterative refinement switch:
    6074             :                 * True - refinement is used.
    6075             :                   Less performance, more precision.
    6076             :                 * False - refinement is not used.
    6077             :                   More performance, less precision.
    6078             : 
    6079             : OUTPUT PARAMETERS
    6080             :     Info    -   return code:
    6081             :                 * -3    matrix is exactly singular (ill conditioned matrices
    6082             :                         are not recognized).
    6083             :                         X is filled by zeros in such cases.
    6084             :                 * -1    N<=0 was passed
    6085             :                 *  1    task is solved
    6086             :     Rep     -   additional report, following fields are set:
    6087             :                 * rep.r1    condition number in 1-norm
    6088             :                 * rep.rinf  condition number in inf-norm
    6089             :     B       -   array[N]:
    6090             :                 * info>0    =>  overwritten by solution
    6091             :                 * info=-3   =>  filled by zeros
    6092             : 
    6093             : 
    6094             :   -- ALGLIB --
    6095             :      Copyright 27.01.2010 by Bochkanov Sergey
    6096             : *************************************************************************/
    6097           0 : void rmatrixsolvemfast(/* Real    */ ae_matrix* a,
    6098             :      ae_int_t n,
    6099             :      /* Real    */ ae_matrix* b,
    6100             :      ae_int_t m,
    6101             :      ae_int_t* info,
    6102             :      ae_state *_state)
    6103             : {
    6104             :     ae_frame _frame_block;
    6105             :     ae_matrix _a;
    6106             :     double v;
    6107             :     ae_int_t i;
    6108             :     ae_int_t j;
    6109             :     ae_int_t k;
    6110             :     ae_vector p;
    6111             : 
    6112           0 :     ae_frame_make(_state, &_frame_block);
    6113           0 :     memset(&_a, 0, sizeof(_a));
    6114           0 :     memset(&p, 0, sizeof(p));
    6115           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    6116           0 :     a = &_a;
    6117           0 :     *info = 0;
    6118           0 :     ae_vector_init(&p, 0, DT_INT, _state, ae_true);
    6119             : 
    6120             :     
    6121             :     /*
    6122             :      * Check for exact degeneracy
    6123             :      */
    6124           0 :     if( n<=0||m<=0 )
    6125             :     {
    6126           0 :         *info = -1;
    6127           0 :         ae_frame_leave(_state);
    6128           0 :         return;
    6129             :     }
    6130           0 :     rmatrixlu(a, n, n, &p, _state);
    6131           0 :     for(i=0; i<=n-1; i++)
    6132             :     {
    6133           0 :         if( ae_fp_eq(a->ptr.pp_double[i][i],(double)(0)) )
    6134             :         {
    6135           0 :             for(j=0; j<=n-1; j++)
    6136             :             {
    6137           0 :                 for(k=0; k<=m-1; k++)
    6138             :                 {
    6139           0 :                     b->ptr.pp_double[j][k] = 0.0;
    6140             :                 }
    6141             :             }
    6142           0 :             *info = -3;
    6143           0 :             ae_frame_leave(_state);
    6144           0 :             return;
    6145             :         }
    6146             :     }
    6147             :     
    6148             :     /*
    6149             :      * Solve with TRSM()
    6150             :      */
    6151           0 :     for(i=0; i<=n-1; i++)
    6152             :     {
    6153           0 :         if( p.ptr.p_int[i]!=i )
    6154             :         {
    6155           0 :             for(j=0; j<=m-1; j++)
    6156             :             {
    6157           0 :                 v = b->ptr.pp_double[i][j];
    6158           0 :                 b->ptr.pp_double[i][j] = b->ptr.pp_double[p.ptr.p_int[i]][j];
    6159           0 :                 b->ptr.pp_double[p.ptr.p_int[i]][j] = v;
    6160             :             }
    6161             :         }
    6162             :     }
    6163           0 :     rmatrixlefttrsm(n, m, a, 0, 0, ae_false, ae_true, 0, b, 0, 0, _state);
    6164           0 :     rmatrixlefttrsm(n, m, a, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    6165           0 :     *info = 1;
    6166           0 :     ae_frame_leave(_state);
    6167             : }
    6168             : 
    6169             : 
    6170             : /*************************************************************************
    6171             : Dense solver.
    6172             : 
    6173             : This  subroutine  solves  a  system  A*x=b,  where A is NxN non-denegerate
    6174             : real matrix given by its LU decomposition, x and b are real vectors.  This
    6175             : is "slow-but-robust" version of the linear LU-based solver. Faster version
    6176             : is RMatrixLUSolveFast() function.
    6177             : 
    6178             : Algorithm features:
    6179             : * automatic detection of degenerate cases
    6180             : * O(N^2) complexity
    6181             : * condition number estimation
    6182             : 
    6183             : No iterative refinement  is provided because exact form of original matrix
    6184             : is not known to subroutine. Use RMatrixSolve or RMatrixMixedSolve  if  you
    6185             : need iterative refinement.
    6186             : 
    6187             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    6188             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    6189             :            ! which results in 10-15x  performance  penalty  when  compared
    6190             :            ! with "fast" version which just calls triangular solver.
    6191             :            !
    6192             :            ! This performance penalty is insignificant  when compared with
    6193             :            ! cost of large LU decomposition.  However,  if you  call  this
    6194             :            ! function many times for the same  left  side,  this  overhead
    6195             :            ! BECOMES significant. It  also  becomes significant for small-
    6196             :            ! scale problems.
    6197             :            !
    6198             :            ! In such cases we strongly recommend you to use faster solver,
    6199             :            ! RMatrixLUSolveFast() function.
    6200             : 
    6201             : INPUT PARAMETERS
    6202             :     LUA     -   array[N,N], LU decomposition, RMatrixLU result
    6203             :     P       -   array[N], pivots array, RMatrixLU result
    6204             :     N       -   size of A
    6205             :     B       -   array[N], right part
    6206             : 
    6207             : OUTPUT PARAMETERS
    6208             :     Info    -   return code:
    6209             :                 * -3    matrix is very badly conditioned or exactly singular.
    6210             :                 * -1    N<=0 was passed
    6211             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    6212             :                         check R1/RInf parameters for condition numbers).
    6213             :     Rep     -   additional report, following fields are set:
    6214             :                 * rep.r1    condition number in 1-norm
    6215             :                 * rep.rinf  condition number in inf-norm
    6216             :     X       -   array[N], it contains:
    6217             :                 * info>0    =>  solution
    6218             :                 * info=-3   =>  filled by zeros
    6219             : 
    6220             :     
    6221             :   -- ALGLIB --
    6222             :      Copyright 27.01.2010 by Bochkanov Sergey
    6223             : *************************************************************************/
    6224           0 : void rmatrixlusolve(/* Real    */ ae_matrix* lua,
    6225             :      /* Integer */ ae_vector* p,
    6226             :      ae_int_t n,
    6227             :      /* Real    */ ae_vector* b,
    6228             :      ae_int_t* info,
    6229             :      densesolverreport* rep,
    6230             :      /* Real    */ ae_vector* x,
    6231             :      ae_state *_state)
    6232             : {
    6233             :     ae_frame _frame_block;
    6234             :     ae_matrix bm;
    6235             :     ae_matrix xm;
    6236             : 
    6237           0 :     ae_frame_make(_state, &_frame_block);
    6238           0 :     memset(&bm, 0, sizeof(bm));
    6239           0 :     memset(&xm, 0, sizeof(xm));
    6240           0 :     *info = 0;
    6241           0 :     _densesolverreport_clear(rep);
    6242           0 :     ae_vector_clear(x);
    6243           0 :     ae_matrix_init(&bm, 0, 0, DT_REAL, _state, ae_true);
    6244           0 :     ae_matrix_init(&xm, 0, 0, DT_REAL, _state, ae_true);
    6245             : 
    6246           0 :     if( n<=0 )
    6247             :     {
    6248           0 :         *info = -1;
    6249           0 :         ae_frame_leave(_state);
    6250           0 :         return;
    6251             :     }
    6252           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    6253           0 :     ae_v_move(&bm.ptr.pp_double[0][0], bm.stride, &b->ptr.p_double[0], 1, ae_v_len(0,n-1));
    6254           0 :     rmatrixlusolvem(lua, p, n, &bm, 1, info, rep, &xm, _state);
    6255           0 :     ae_vector_set_length(x, n, _state);
    6256           0 :     ae_v_move(&x->ptr.p_double[0], 1, &xm.ptr.pp_double[0][0], xm.stride, ae_v_len(0,n-1));
    6257           0 :     ae_frame_leave(_state);
    6258             : }
    6259             : 
    6260             : 
    6261             : /*************************************************************************
    6262             : Dense solver.
    6263             : 
    6264             : This  subroutine  solves  a  system  A*x=b,  where A is NxN non-denegerate
    6265             : real matrix given by its LU decomposition, x and b are real vectors.  This
    6266             : is "fast-without-any-checks" version of the linear LU-based solver. Slower
    6267             : but more robust version is RMatrixLUSolve() function.
    6268             : 
    6269             : Algorithm features:
    6270             : * O(N^2) complexity
    6271             : * fast algorithm without ANY additional checks, just triangular solver
    6272             : 
    6273             : INPUT PARAMETERS
    6274             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    6275             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    6276             :     N       -   size of A
    6277             :     B       -   array[0..N-1], right part
    6278             : 
    6279             : OUTPUT PARAMETERS
    6280             :     Info    -   return code:
    6281             :                 * -3    matrix is exactly singular (ill conditioned matrices
    6282             :                         are not recognized).
    6283             :                         X is filled by zeros in such cases.
    6284             :                 * -1    N<=0 was passed
    6285             :                 *  1    task is solved 
    6286             :     B       -   array[N]:
    6287             :                 * info>0    =>  overwritten by solution
    6288             :                 * info=-3   =>  filled by zeros
    6289             : 
    6290             :   -- ALGLIB --
    6291             :      Copyright 18.03.2015 by Bochkanov Sergey
    6292             : *************************************************************************/
    6293           0 : void rmatrixlusolvefast(/* Real    */ ae_matrix* lua,
    6294             :      /* Integer */ ae_vector* p,
    6295             :      ae_int_t n,
    6296             :      /* Real    */ ae_vector* b,
    6297             :      ae_int_t* info,
    6298             :      ae_state *_state)
    6299             : {
    6300             :     ae_int_t i;
    6301             :     ae_int_t j;
    6302             : 
    6303           0 :     *info = 0;
    6304             : 
    6305           0 :     if( n<=0 )
    6306             :     {
    6307           0 :         *info = -1;
    6308           0 :         return;
    6309             :     }
    6310           0 :     for(i=0; i<=n-1; i++)
    6311             :     {
    6312           0 :         if( ae_fp_eq(lua->ptr.pp_double[i][i],(double)(0)) )
    6313             :         {
    6314           0 :             for(j=0; j<=n-1; j++)
    6315             :             {
    6316           0 :                 b->ptr.p_double[j] = 0.0;
    6317             :             }
    6318           0 :             *info = -3;
    6319           0 :             return;
    6320             :         }
    6321             :     }
    6322           0 :     directdensesolvers_rbasiclusolve(lua, p, n, b, _state);
    6323           0 :     *info = 1;
    6324             : }
    6325             : 
    6326             : 
    6327             : /*************************************************************************
    6328             : Dense solver.
    6329             : 
    6330             : Similar to RMatrixLUSolve() but solves  task  with  multiple  right  parts
    6331             : (where b and x are NxM matrices). This  is  "robust-but-slow"  version  of
    6332             : LU-based solver which performs additional  checks  for  non-degeneracy  of
    6333             : inputs (condition number estimation). If you need  best  performance,  use
    6334             : "fast-without-any-checks" version, RMatrixLUSolveMFast().
    6335             : 
    6336             : Algorithm features:
    6337             : * automatic detection of degenerate cases
    6338             : * O(M*N^2) complexity
    6339             : * condition number estimation
    6340             : 
    6341             : No iterative refinement  is provided because exact form of original matrix
    6342             : is not known to subroutine. Use RMatrixSolve or RMatrixMixedSolve  if  you
    6343             : need iterative refinement.
    6344             : 
    6345             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    6346             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    6347             :            ! which  results  in  significant  performance   penalty   when
    6348             :            ! compared with "fast"  version  which  just  calls  triangular
    6349             :            ! solver.
    6350             :            !
    6351             :            ! This performance penalty is especially apparent when you  use
    6352             :            ! ALGLIB parallel capabilities (condition number estimation  is
    6353             :            ! inherently  sequential).  It   also   becomes significant for
    6354             :            ! small-scale problems.
    6355             :            !
    6356             :            ! In such cases we strongly recommend you to use faster solver,
    6357             :            ! RMatrixLUSolveMFast() function.
    6358             : 
    6359             :   ! COMMERCIAL EDITION OF ALGLIB:
    6360             :   ! 
    6361             :   ! Commercial Edition of ALGLIB includes following important improvements
    6362             :   ! of this function:
    6363             :   ! * high-performance native backend with same C# interface (C# version)
    6364             :   ! * multithreading support (C++ and C# versions)
    6365             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    6366             :   !   (C++ and C# versions, x86/x64 platform)
    6367             :   ! 
    6368             :   ! We recommend you to read 'Working with commercial version' section  of
    6369             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    6370             :   ! related features provided by commercial edition of ALGLIB.
    6371             :   
    6372             : INPUT PARAMETERS
    6373             :     LUA     -   array[N,N], LU decomposition, RMatrixLU result
    6374             :     P       -   array[N], pivots array, RMatrixLU result
    6375             :     N       -   size of A
    6376             :     B       -   array[0..N-1,0..M-1], right part
    6377             :     M       -   right part size
    6378             : 
    6379             : OUTPUT PARAMETERS
    6380             :     Info    -   return code:
    6381             :                 * -3    matrix is very badly conditioned or exactly singular.
    6382             :                         X is filled by zeros in such cases.
    6383             :                 * -1    N<=0 was passed
    6384             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    6385             :                         check R1/RInf parameters for condition numbers).
    6386             :     Rep     -   additional report, following fields are set:
    6387             :                 * rep.r1    condition number in 1-norm
    6388             :                 * rep.rinf  condition number in inf-norm
    6389             :     X       -   array[N,M], it contains:
    6390             :                 * info>0    =>  solution
    6391             :                 * info=-3   =>  filled by zeros
    6392             : 
    6393             : 
    6394             :   -- ALGLIB --
    6395             :      Copyright 27.01.2010 by Bochkanov Sergey
    6396             : *************************************************************************/
    6397           0 : void rmatrixlusolvem(/* Real    */ ae_matrix* lua,
    6398             :      /* Integer */ ae_vector* p,
    6399             :      ae_int_t n,
    6400             :      /* Real    */ ae_matrix* b,
    6401             :      ae_int_t m,
    6402             :      ae_int_t* info,
    6403             :      densesolverreport* rep,
    6404             :      /* Real    */ ae_matrix* x,
    6405             :      ae_state *_state)
    6406             : {
    6407             :     ae_frame _frame_block;
    6408             :     ae_matrix emptya;
    6409             : 
    6410           0 :     ae_frame_make(_state, &_frame_block);
    6411           0 :     memset(&emptya, 0, sizeof(emptya));
    6412           0 :     *info = 0;
    6413           0 :     _densesolverreport_clear(rep);
    6414           0 :     ae_matrix_clear(x);
    6415           0 :     ae_matrix_init(&emptya, 0, 0, DT_REAL, _state, ae_true);
    6416             : 
    6417             :     
    6418             :     /*
    6419             :      * prepare: check inputs, allocate space...
    6420             :      */
    6421           0 :     if( n<=0||m<=0 )
    6422             :     {
    6423           0 :         *info = -1;
    6424           0 :         ae_frame_leave(_state);
    6425           0 :         return;
    6426             :     }
    6427             :     
    6428             :     /*
    6429             :      * solve
    6430             :      */
    6431           0 :     directdensesolvers_rmatrixlusolveinternal(lua, p, n, &emptya, ae_false, b, m, info, rep, x, _state);
    6432           0 :     ae_frame_leave(_state);
    6433             : }
    6434             : 
    6435             : 
    6436             : /*************************************************************************
    6437             : Dense solver.
    6438             : 
    6439             : Similar to RMatrixLUSolve() but solves  task  with  multiple  right parts,
    6440             : where b and x are NxM matrices.  This is "fast-without-any-checks" version
    6441             : of LU-based solver. It does not estimate  condition number  of  a  system,
    6442             : so it is extremely fast. If you need better detection  of  near-degenerate
    6443             : cases, use RMatrixLUSolveM() function.
    6444             : 
    6445             : Algorithm features:
    6446             : * O(M*N^2) complexity
    6447             : * fast algorithm without ANY additional checks, just triangular solver
    6448             : 
    6449             :   ! COMMERCIAL EDITION OF ALGLIB:
    6450             :   ! 
    6451             :   ! Commercial Edition of ALGLIB includes following important improvements
    6452             :   ! of this function:
    6453             :   ! * high-performance native backend with same C# interface (C# version)
    6454             :   ! * multithreading support (C++ and C# versions)
    6455             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    6456             :   !   (C++ and C# versions, x86/x64 platform)
    6457             :   ! 
    6458             :   ! We recommend you to read 'Working with commercial version' section  of
    6459             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    6460             :   ! related features provided by commercial edition of ALGLIB.
    6461             : 
    6462             : INPUT PARAMETERS:
    6463             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    6464             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    6465             :     N       -   size of A
    6466             :     B       -   array[0..N-1,0..M-1], right part
    6467             :     M       -   right part size
    6468             : 
    6469             : OUTPUT PARAMETERS:
    6470             :     Info    -   return code:
    6471             :                 * -3    matrix is exactly singular (ill conditioned matrices
    6472             :                         are not recognized).
    6473             :                 * -1    N<=0 was passed
    6474             :                 *  1    task is solved
    6475             :     B       -   array[N,M]:
    6476             :                 * info>0    =>  overwritten by solution
    6477             :                 * info=-3   =>  filled by zeros
    6478             : 
    6479             :   -- ALGLIB --
    6480             :      Copyright 18.03.2015 by Bochkanov Sergey
    6481             : *************************************************************************/
    6482           0 : void rmatrixlusolvemfast(/* Real    */ ae_matrix* lua,
    6483             :      /* Integer */ ae_vector* p,
    6484             :      ae_int_t n,
    6485             :      /* Real    */ ae_matrix* b,
    6486             :      ae_int_t m,
    6487             :      ae_int_t* info,
    6488             :      ae_state *_state)
    6489             : {
    6490             :     double v;
    6491             :     ae_int_t i;
    6492             :     ae_int_t j;
    6493             :     ae_int_t k;
    6494             : 
    6495           0 :     *info = 0;
    6496             : 
    6497             :     
    6498             :     /*
    6499             :      * Check for exact degeneracy
    6500             :      */
    6501           0 :     if( n<=0||m<=0 )
    6502             :     {
    6503           0 :         *info = -1;
    6504           0 :         return;
    6505             :     }
    6506           0 :     for(i=0; i<=n-1; i++)
    6507             :     {
    6508           0 :         if( ae_fp_eq(lua->ptr.pp_double[i][i],(double)(0)) )
    6509             :         {
    6510           0 :             for(j=0; j<=n-1; j++)
    6511             :             {
    6512           0 :                 for(k=0; k<=m-1; k++)
    6513             :                 {
    6514           0 :                     b->ptr.pp_double[j][k] = 0.0;
    6515             :                 }
    6516             :             }
    6517           0 :             *info = -3;
    6518           0 :             return;
    6519             :         }
    6520             :     }
    6521             :     
    6522             :     /*
    6523             :      * Solve with TRSM()
    6524             :      */
    6525           0 :     for(i=0; i<=n-1; i++)
    6526             :     {
    6527           0 :         if( p->ptr.p_int[i]!=i )
    6528             :         {
    6529           0 :             for(j=0; j<=m-1; j++)
    6530             :             {
    6531           0 :                 v = b->ptr.pp_double[i][j];
    6532           0 :                 b->ptr.pp_double[i][j] = b->ptr.pp_double[p->ptr.p_int[i]][j];
    6533           0 :                 b->ptr.pp_double[p->ptr.p_int[i]][j] = v;
    6534             :             }
    6535             :         }
    6536             :     }
    6537           0 :     rmatrixlefttrsm(n, m, lua, 0, 0, ae_false, ae_true, 0, b, 0, 0, _state);
    6538           0 :     rmatrixlefttrsm(n, m, lua, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    6539           0 :     *info = 1;
    6540             : }
    6541             : 
    6542             : 
    6543             : /*************************************************************************
    6544             : Dense solver.
    6545             : 
    6546             : This  subroutine  solves  a  system  A*x=b,  where BOTH ORIGINAL A AND ITS
    6547             : LU DECOMPOSITION ARE KNOWN. You can use it if for some  reasons  you  have
    6548             : both A and its LU decomposition.
    6549             : 
    6550             : Algorithm features:
    6551             : * automatic detection of degenerate cases
    6552             : * condition number estimation
    6553             : * iterative refinement
    6554             : * O(N^2) complexity
    6555             : 
    6556             : INPUT PARAMETERS
    6557             :     A       -   array[0..N-1,0..N-1], system matrix
    6558             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    6559             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    6560             :     N       -   size of A
    6561             :     B       -   array[0..N-1], right part
    6562             : 
    6563             : OUTPUT PARAMETERS
    6564             :     Info    -   return code:
    6565             :                 * -3    matrix is very badly conditioned or exactly singular.
    6566             :                 * -1    N<=0 was passed
    6567             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    6568             :                         check R1/RInf parameters for condition numbers).
    6569             :     Rep     -   additional report, following fields are set:
    6570             :                 * rep.r1    condition number in 1-norm
    6571             :                 * rep.rinf  condition number in inf-norm
    6572             :     X       -   array[N], it contains:
    6573             :                 * info>0    =>  solution
    6574             :                 * info=-3   =>  filled by zeros
    6575             : 
    6576             :   -- ALGLIB --
    6577             :      Copyright 27.01.2010 by Bochkanov Sergey
    6578             : *************************************************************************/
    6579           0 : void rmatrixmixedsolve(/* Real    */ ae_matrix* a,
    6580             :      /* Real    */ ae_matrix* lua,
    6581             :      /* Integer */ ae_vector* p,
    6582             :      ae_int_t n,
    6583             :      /* Real    */ ae_vector* b,
    6584             :      ae_int_t* info,
    6585             :      densesolverreport* rep,
    6586             :      /* Real    */ ae_vector* x,
    6587             :      ae_state *_state)
    6588             : {
    6589             :     ae_frame _frame_block;
    6590             :     ae_matrix bm;
    6591             :     ae_matrix xm;
    6592             : 
    6593           0 :     ae_frame_make(_state, &_frame_block);
    6594           0 :     memset(&bm, 0, sizeof(bm));
    6595           0 :     memset(&xm, 0, sizeof(xm));
    6596           0 :     *info = 0;
    6597           0 :     _densesolverreport_clear(rep);
    6598           0 :     ae_vector_clear(x);
    6599           0 :     ae_matrix_init(&bm, 0, 0, DT_REAL, _state, ae_true);
    6600           0 :     ae_matrix_init(&xm, 0, 0, DT_REAL, _state, ae_true);
    6601             : 
    6602           0 :     if( n<=0 )
    6603             :     {
    6604           0 :         *info = -1;
    6605           0 :         ae_frame_leave(_state);
    6606           0 :         return;
    6607             :     }
    6608           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    6609           0 :     ae_v_move(&bm.ptr.pp_double[0][0], bm.stride, &b->ptr.p_double[0], 1, ae_v_len(0,n-1));
    6610           0 :     rmatrixmixedsolvem(a, lua, p, n, &bm, 1, info, rep, &xm, _state);
    6611           0 :     ae_vector_set_length(x, n, _state);
    6612           0 :     ae_v_move(&x->ptr.p_double[0], 1, &xm.ptr.pp_double[0][0], xm.stride, ae_v_len(0,n-1));
    6613           0 :     ae_frame_leave(_state);
    6614             : }
    6615             : 
    6616             : 
    6617             : /*************************************************************************
    6618             : Dense solver.
    6619             : 
    6620             : Similar to RMatrixMixedSolve() but  solves task with multiple right  parts
    6621             : (where b and x are NxM matrices).
    6622             : 
    6623             : Algorithm features:
    6624             : * automatic detection of degenerate cases
    6625             : * condition number estimation
    6626             : * iterative refinement
    6627             : * O(M*N^2) complexity
    6628             : 
    6629             : INPUT PARAMETERS
    6630             :     A       -   array[0..N-1,0..N-1], system matrix
    6631             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    6632             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    6633             :     N       -   size of A
    6634             :     B       -   array[0..N-1,0..M-1], right part
    6635             :     M       -   right part size
    6636             : 
    6637             : OUTPUT PARAMETERS
    6638             :     Info    -   return code:
    6639             :                 * -3    matrix is very badly conditioned or exactly singular.
    6640             :                 * -1    N<=0 was passed
    6641             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    6642             :                         check R1/RInf parameters for condition numbers).
    6643             :     Rep     -   additional report, following fields are set:
    6644             :                 * rep.r1    condition number in 1-norm
    6645             :                 * rep.rinf  condition number in inf-norm
    6646             :     X       -   array[N,M], it contains:
    6647             :                 * info>0    =>  solution
    6648             :                 * info=-3   =>  filled by zeros
    6649             : 
    6650             :   -- ALGLIB --
    6651             :      Copyright 27.01.2010 by Bochkanov Sergey
    6652             : *************************************************************************/
    6653           0 : void rmatrixmixedsolvem(/* Real    */ ae_matrix* a,
    6654             :      /* Real    */ ae_matrix* lua,
    6655             :      /* Integer */ ae_vector* p,
    6656             :      ae_int_t n,
    6657             :      /* Real    */ ae_matrix* b,
    6658             :      ae_int_t m,
    6659             :      ae_int_t* info,
    6660             :      densesolverreport* rep,
    6661             :      /* Real    */ ae_matrix* x,
    6662             :      ae_state *_state)
    6663             : {
    6664             : 
    6665           0 :     *info = 0;
    6666           0 :     _densesolverreport_clear(rep);
    6667           0 :     ae_matrix_clear(x);
    6668             : 
    6669             :     
    6670             :     /*
    6671             :      * prepare: check inputs, allocate space...
    6672             :      */
    6673           0 :     if( n<=0||m<=0 )
    6674             :     {
    6675           0 :         *info = -1;
    6676           0 :         return;
    6677             :     }
    6678             :     
    6679             :     /*
    6680             :      * solve
    6681             :      */
    6682           0 :     directdensesolvers_rmatrixlusolveinternal(lua, p, n, a, ae_true, b, m, info, rep, x, _state);
    6683             : }
    6684             : 
    6685             : 
    6686             : /*************************************************************************
    6687             : Complex dense solver for A*X=B with N*N  complex  matrix  A,  N*M  complex
    6688             : matrices  X  and  B.  "Slow-but-feature-rich"   version   which   provides
    6689             : additional functions, at the cost of slower  performance.  Faster  version
    6690             : may be invoked with CMatrixSolveMFast() function.
    6691             : 
    6692             : Algorithm features:
    6693             : * automatic detection of degenerate cases
    6694             : * condition number estimation
    6695             : * iterative refinement
    6696             : * O(N^3+M*N^2) complexity
    6697             : 
    6698             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    6699             :            ! by ALGLIB. It estimates condition  number  of  linear  system
    6700             :            ! and  performs  iterative   refinement,   which   results   in
    6701             :            ! significant performance penalty  when  compared  with  "fast"
    6702             :            ! version  which  just  performs  LU  decomposition  and  calls
    6703             :            ! triangular solver.
    6704             :            !
    6705             :            ! This  performance  penalty  is  especially  visible  in   the
    6706             :            ! multithreaded mode, because both condition number  estimation
    6707             :            ! and   iterative    refinement   are   inherently   sequential
    6708             :            ! calculations.
    6709             :            !
    6710             :            ! Thus, if you need high performance and if you are pretty sure
    6711             :            ! that your system is well conditioned, we  strongly  recommend
    6712             :            ! you to use faster solver, CMatrixSolveMFast() function.
    6713             : 
    6714             :   ! COMMERCIAL EDITION OF ALGLIB:
    6715             :   ! 
    6716             :   ! Commercial Edition of ALGLIB includes following important improvements
    6717             :   ! of this function:
    6718             :   ! * high-performance native backend with same C# interface (C# version)
    6719             :   ! * multithreading support (C++ and C# versions)
    6720             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    6721             :   !   (C++ and C# versions, x86/x64 platform)
    6722             :   ! 
    6723             :   ! We recommend you to read 'Working with commercial version' section  of
    6724             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    6725             :   ! related features provided by commercial edition of ALGLIB.
    6726             : 
    6727             : INPUT PARAMETERS
    6728             :     A       -   array[0..N-1,0..N-1], system matrix
    6729             :     N       -   size of A
    6730             :     B       -   array[0..N-1,0..M-1], right part
    6731             :     M       -   right part size
    6732             :     RFS     -   iterative refinement switch:
    6733             :                 * True - refinement is used.
    6734             :                   Less performance, more precision.
    6735             :                 * False - refinement is not used.
    6736             :                   More performance, less precision.
    6737             : 
    6738             : OUTPUT PARAMETERS
    6739             :     Info    -   return code:
    6740             :                 * -3    matrix is very badly conditioned or exactly singular.
    6741             :                         X is filled by zeros in such cases.
    6742             :                 * -1    N<=0 was passed
    6743             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    6744             :                         check R1/RInf parameters for condition numbers).
    6745             :     Rep     -   additional report, following fields are set:
    6746             :                 * rep.r1    condition number in 1-norm
    6747             :                 * rep.rinf  condition number in inf-norm
    6748             :     X       -   array[N,M], it contains:
    6749             :                 * info>0    =>  solution
    6750             :                 * info=-3   =>  filled by zeros
    6751             : 
    6752             :   -- ALGLIB --
    6753             :      Copyright 27.01.2010 by Bochkanov Sergey
    6754             : *************************************************************************/
    6755           0 : void cmatrixsolvem(/* Complex */ ae_matrix* a,
    6756             :      ae_int_t n,
    6757             :      /* Complex */ ae_matrix* b,
    6758             :      ae_int_t m,
    6759             :      ae_bool rfs,
    6760             :      ae_int_t* info,
    6761             :      densesolverreport* rep,
    6762             :      /* Complex */ ae_matrix* x,
    6763             :      ae_state *_state)
    6764             : {
    6765             :     ae_frame _frame_block;
    6766             :     ae_matrix da;
    6767             :     ae_matrix emptya;
    6768             :     ae_vector p;
    6769             :     ae_int_t i;
    6770             : 
    6771           0 :     ae_frame_make(_state, &_frame_block);
    6772           0 :     memset(&da, 0, sizeof(da));
    6773           0 :     memset(&emptya, 0, sizeof(emptya));
    6774           0 :     memset(&p, 0, sizeof(p));
    6775           0 :     *info = 0;
    6776           0 :     _densesolverreport_clear(rep);
    6777           0 :     ae_matrix_clear(x);
    6778           0 :     ae_matrix_init(&da, 0, 0, DT_COMPLEX, _state, ae_true);
    6779           0 :     ae_matrix_init(&emptya, 0, 0, DT_COMPLEX, _state, ae_true);
    6780           0 :     ae_vector_init(&p, 0, DT_INT, _state, ae_true);
    6781             : 
    6782             :     
    6783             :     /*
    6784             :      * prepare: check inputs, allocate space...
    6785             :      */
    6786           0 :     if( n<=0||m<=0 )
    6787             :     {
    6788           0 :         *info = -1;
    6789           0 :         ae_frame_leave(_state);
    6790           0 :         return;
    6791             :     }
    6792           0 :     ae_matrix_set_length(&da, n, n, _state);
    6793             :     
    6794             :     /*
    6795             :      * factorize, solve
    6796             :      */
    6797           0 :     for(i=0; i<=n-1; i++)
    6798             :     {
    6799           0 :         ae_v_cmove(&da.ptr.pp_complex[i][0], 1, &a->ptr.pp_complex[i][0], 1, "N", ae_v_len(0,n-1));
    6800             :     }
    6801           0 :     cmatrixlu(&da, n, n, &p, _state);
    6802           0 :     if( rfs )
    6803             :     {
    6804           0 :         directdensesolvers_cmatrixlusolveinternal(&da, &p, n, a, ae_true, b, m, info, rep, x, _state);
    6805             :     }
    6806             :     else
    6807             :     {
    6808           0 :         directdensesolvers_cmatrixlusolveinternal(&da, &p, n, &emptya, ae_false, b, m, info, rep, x, _state);
    6809             :     }
    6810           0 :     ae_frame_leave(_state);
    6811             : }
    6812             : 
    6813             : 
    6814             : /*************************************************************************
    6815             : Complex dense solver for A*X=B with N*N  complex  matrix  A,  N*M  complex
    6816             : matrices  X  and  B.  "Fast-but-lightweight" version which  provides  just
    6817             : triangular solver - and no additional functions like iterative  refinement
    6818             : or condition number estimation.
    6819             : 
    6820             : Algorithm features:
    6821             : * O(N^3+M*N^2) complexity
    6822             : * no additional time consuming functions
    6823             : 
    6824             :   ! COMMERCIAL EDITION OF ALGLIB:
    6825             :   ! 
    6826             :   ! Commercial Edition of ALGLIB includes following important improvements
    6827             :   ! of this function:
    6828             :   ! * high-performance native backend with same C# interface (C# version)
    6829             :   ! * multithreading support (C++ and C# versions)
    6830             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    6831             :   !   (C++ and C# versions, x86/x64 platform)
    6832             :   ! 
    6833             :   ! We recommend you to read 'Working with commercial version' section  of
    6834             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    6835             :   ! related features provided by commercial edition of ALGLIB.
    6836             : 
    6837             : INPUT PARAMETERS
    6838             :     A       -   array[0..N-1,0..N-1], system matrix
    6839             :     N       -   size of A
    6840             :     B       -   array[0..N-1,0..M-1], right part
    6841             :     M       -   right part size
    6842             : 
    6843             : OUTPUT PARAMETERS:
    6844             :     Info    -   return code:
    6845             :                 * -3    matrix is exactly singular (ill conditioned matrices
    6846             :                         are not recognized).
    6847             :                 * -1    N<=0 was passed
    6848             :                 *  1    task is solved 
    6849             :     B       -   array[N,M]:
    6850             :                 * info>0    =>  overwritten by solution
    6851             :                 * info=-3   =>  filled by zeros
    6852             : 
    6853             :   -- ALGLIB --
    6854             :      Copyright 16.03.2015 by Bochkanov Sergey
    6855             : *************************************************************************/
    6856           0 : void cmatrixsolvemfast(/* Complex */ ae_matrix* a,
    6857             :      ae_int_t n,
    6858             :      /* Complex */ ae_matrix* b,
    6859             :      ae_int_t m,
    6860             :      ae_int_t* info,
    6861             :      ae_state *_state)
    6862             : {
    6863             :     ae_frame _frame_block;
    6864             :     ae_matrix _a;
    6865             :     ae_complex v;
    6866             :     ae_int_t i;
    6867             :     ae_int_t j;
    6868             :     ae_int_t k;
    6869             :     ae_vector p;
    6870             : 
    6871           0 :     ae_frame_make(_state, &_frame_block);
    6872           0 :     memset(&_a, 0, sizeof(_a));
    6873           0 :     memset(&p, 0, sizeof(p));
    6874           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    6875           0 :     a = &_a;
    6876           0 :     *info = 0;
    6877           0 :     ae_vector_init(&p, 0, DT_INT, _state, ae_true);
    6878             : 
    6879             :     
    6880             :     /*
    6881             :      * Check for exact degeneracy
    6882             :      */
    6883           0 :     if( n<=0||m<=0 )
    6884             :     {
    6885           0 :         *info = -1;
    6886           0 :         ae_frame_leave(_state);
    6887           0 :         return;
    6888             :     }
    6889           0 :     cmatrixlu(a, n, n, &p, _state);
    6890           0 :     for(i=0; i<=n-1; i++)
    6891             :     {
    6892           0 :         if( ae_c_eq_d(a->ptr.pp_complex[i][i],(double)(0)) )
    6893             :         {
    6894           0 :             for(j=0; j<=n-1; j++)
    6895             :             {
    6896           0 :                 for(k=0; k<=m-1; k++)
    6897             :                 {
    6898           0 :                     b->ptr.pp_complex[j][k] = ae_complex_from_d(0.0);
    6899             :                 }
    6900             :             }
    6901           0 :             *info = -3;
    6902           0 :             ae_frame_leave(_state);
    6903           0 :             return;
    6904             :         }
    6905             :     }
    6906             :     
    6907             :     /*
    6908             :      * Solve with TRSM()
    6909             :      */
    6910           0 :     for(i=0; i<=n-1; i++)
    6911             :     {
    6912           0 :         if( p.ptr.p_int[i]!=i )
    6913             :         {
    6914           0 :             for(j=0; j<=m-1; j++)
    6915             :             {
    6916           0 :                 v = b->ptr.pp_complex[i][j];
    6917           0 :                 b->ptr.pp_complex[i][j] = b->ptr.pp_complex[p.ptr.p_int[i]][j];
    6918           0 :                 b->ptr.pp_complex[p.ptr.p_int[i]][j] = v;
    6919             :             }
    6920             :         }
    6921             :     }
    6922           0 :     cmatrixlefttrsm(n, m, a, 0, 0, ae_false, ae_true, 0, b, 0, 0, _state);
    6923           0 :     cmatrixlefttrsm(n, m, a, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    6924           0 :     *info = 1;
    6925           0 :     ae_frame_leave(_state);
    6926             : }
    6927             : 
    6928             : 
    6929             : /*************************************************************************
    6930             : Complex dense solver for A*x=B with N*N complex matrix A and  N*1  complex
    6931             : vectors x and b. "Slow-but-feature-rich" version of the solver.
    6932             : 
    6933             : Algorithm features:
    6934             : * automatic detection of degenerate cases
    6935             : * condition number estimation
    6936             : * iterative refinement
    6937             : * O(N^3) complexity
    6938             : 
    6939             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    6940             :            ! by ALGLIB. It estimates condition  number  of  linear  system
    6941             :            ! and  performs  iterative   refinement,   which   results   in
    6942             :            ! significant performance penalty  when  compared  with  "fast"
    6943             :            ! version  which  just  performs  LU  decomposition  and  calls
    6944             :            ! triangular solver.
    6945             :            !
    6946             :            ! This  performance  penalty  is  especially  visible  in   the
    6947             :            ! multithreaded mode, because both condition number  estimation
    6948             :            ! and   iterative    refinement   are   inherently   sequential
    6949             :            ! calculations.
    6950             :            !
    6951             :            ! Thus, if you need high performance and if you are pretty sure
    6952             :            ! that your system is well conditioned, we  strongly  recommend
    6953             :            ! you to use faster solver, CMatrixSolveFast() function.
    6954             : 
    6955             :   ! COMMERCIAL EDITION OF ALGLIB:
    6956             :   ! 
    6957             :   ! Commercial Edition of ALGLIB includes following important improvements
    6958             :   ! of this function:
    6959             :   ! * high-performance native backend with same C# interface (C# version)
    6960             :   ! * multithreading support (C++ and C# versions)
    6961             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    6962             :   !   (C++ and C# versions, x86/x64 platform)
    6963             :   ! 
    6964             :   ! We recommend you to read 'Working with commercial version' section  of
    6965             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    6966             :   ! related features provided by commercial edition of ALGLIB.
    6967             : 
    6968             : INPUT PARAMETERS
    6969             :     A       -   array[0..N-1,0..N-1], system matrix
    6970             :     N       -   size of A
    6971             :     B       -   array[0..N-1], right part
    6972             : 
    6973             : OUTPUT PARAMETERS
    6974             :     Info    -   return code:
    6975             :                 * -3    matrix is very badly conditioned or exactly singular.
    6976             :                 * -1    N<=0 was passed
    6977             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    6978             :                         check R1/RInf parameters for condition numbers).
    6979             :     Rep     -   additional report, following fields are set:
    6980             :                 * rep.r1    condition number in 1-norm
    6981             :                 * rep.rinf  condition number in inf-norm
    6982             :     X       -   array[N], it contains:
    6983             :                 * info>0    =>  solution
    6984             :                 * info=-3   =>  filled by zeros
    6985             : 
    6986             :   -- ALGLIB --
    6987             :      Copyright 27.01.2010 by Bochkanov Sergey
    6988             : *************************************************************************/
    6989           0 : void cmatrixsolve(/* Complex */ ae_matrix* a,
    6990             :      ae_int_t n,
    6991             :      /* Complex */ ae_vector* b,
    6992             :      ae_int_t* info,
    6993             :      densesolverreport* rep,
    6994             :      /* Complex */ ae_vector* x,
    6995             :      ae_state *_state)
    6996             : {
    6997             :     ae_frame _frame_block;
    6998             :     ae_matrix bm;
    6999             :     ae_matrix xm;
    7000             : 
    7001           0 :     ae_frame_make(_state, &_frame_block);
    7002           0 :     memset(&bm, 0, sizeof(bm));
    7003           0 :     memset(&xm, 0, sizeof(xm));
    7004           0 :     *info = 0;
    7005           0 :     _densesolverreport_clear(rep);
    7006           0 :     ae_vector_clear(x);
    7007           0 :     ae_matrix_init(&bm, 0, 0, DT_COMPLEX, _state, ae_true);
    7008           0 :     ae_matrix_init(&xm, 0, 0, DT_COMPLEX, _state, ae_true);
    7009             : 
    7010           0 :     if( n<=0 )
    7011             :     {
    7012           0 :         *info = -1;
    7013           0 :         ae_frame_leave(_state);
    7014           0 :         return;
    7015             :     }
    7016           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    7017           0 :     ae_v_cmove(&bm.ptr.pp_complex[0][0], bm.stride, &b->ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    7018           0 :     cmatrixsolvem(a, n, &bm, 1, ae_true, info, rep, &xm, _state);
    7019           0 :     ae_vector_set_length(x, n, _state);
    7020           0 :     ae_v_cmove(&x->ptr.p_complex[0], 1, &xm.ptr.pp_complex[0][0], xm.stride, "N", ae_v_len(0,n-1));
    7021           0 :     ae_frame_leave(_state);
    7022             : }
    7023             : 
    7024             : 
    7025             : /*************************************************************************
    7026             : Complex dense solver for A*x=B with N*N complex matrix A and  N*1  complex
    7027             : vectors x and b. "Fast-but-lightweight" version of the solver.
    7028             : 
    7029             : Algorithm features:
    7030             : * O(N^3) complexity
    7031             : * no additional time consuming features, just triangular solver
    7032             : 
    7033             :   ! COMMERCIAL EDITION OF ALGLIB:
    7034             :   ! 
    7035             :   ! Commercial Edition of ALGLIB includes following important improvements
    7036             :   ! of this function:
    7037             :   ! * high-performance native backend with same C# interface (C# version)
    7038             :   ! * multithreading support (C++ and C# versions)
    7039             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    7040             :   !   (C++ and C# versions, x86/x64 platform)
    7041             :   ! 
    7042             :   ! We recommend you to read 'Working with commercial version' section  of
    7043             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    7044             :   ! related features provided by commercial edition of ALGLIB.
    7045             : 
    7046             : INPUT PARAMETERS:
    7047             :     A       -   array[0..N-1,0..N-1], system matrix
    7048             :     N       -   size of A
    7049             :     B       -   array[0..N-1], right part
    7050             : 
    7051             : OUTPUT PARAMETERS:
    7052             :     Info    -   return code:
    7053             :                 * -3    matrix is exactly singular (ill conditioned matrices
    7054             :                         are not recognized).
    7055             :                 * -1    N<=0 was passed
    7056             :                 *  1    task is solved 
    7057             :     B       -   array[N]:
    7058             :                 * info>0    =>  overwritten by solution
    7059             :                 * info=-3   =>  filled by zeros
    7060             : 
    7061             :   -- ALGLIB --
    7062             :      Copyright 27.01.2010 by Bochkanov Sergey
    7063             : *************************************************************************/
    7064           0 : void cmatrixsolvefast(/* Complex */ ae_matrix* a,
    7065             :      ae_int_t n,
    7066             :      /* Complex */ ae_vector* b,
    7067             :      ae_int_t* info,
    7068             :      ae_state *_state)
    7069             : {
    7070             :     ae_frame _frame_block;
    7071             :     ae_matrix _a;
    7072             :     ae_int_t i;
    7073             :     ae_int_t j;
    7074             :     ae_vector p;
    7075             : 
    7076           0 :     ae_frame_make(_state, &_frame_block);
    7077           0 :     memset(&_a, 0, sizeof(_a));
    7078           0 :     memset(&p, 0, sizeof(p));
    7079           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    7080           0 :     a = &_a;
    7081           0 :     *info = 0;
    7082           0 :     ae_vector_init(&p, 0, DT_INT, _state, ae_true);
    7083             : 
    7084           0 :     if( n<=0 )
    7085             :     {
    7086           0 :         *info = -1;
    7087           0 :         ae_frame_leave(_state);
    7088           0 :         return;
    7089             :     }
    7090           0 :     cmatrixlu(a, n, n, &p, _state);
    7091           0 :     for(i=0; i<=n-1; i++)
    7092             :     {
    7093           0 :         if( ae_c_eq_d(a->ptr.pp_complex[i][i],(double)(0)) )
    7094             :         {
    7095           0 :             for(j=0; j<=n-1; j++)
    7096             :             {
    7097           0 :                 b->ptr.p_complex[j] = ae_complex_from_d(0.0);
    7098             :             }
    7099           0 :             *info = -3;
    7100           0 :             ae_frame_leave(_state);
    7101           0 :             return;
    7102             :         }
    7103             :     }
    7104           0 :     directdensesolvers_cbasiclusolve(a, &p, n, b, _state);
    7105           0 :     *info = 1;
    7106           0 :     ae_frame_leave(_state);
    7107             : }
    7108             : 
    7109             : 
    7110             : /*************************************************************************
    7111             : Dense solver for A*X=B with N*N complex A given by its  LU  decomposition,
    7112             : and N*M matrices X and B (multiple right sides).   "Slow-but-feature-rich"
    7113             : version of the solver.
    7114             : 
    7115             : Algorithm features:
    7116             : * automatic detection of degenerate cases
    7117             : * O(M*N^2) complexity
    7118             : * condition number estimation
    7119             : 
    7120             : No iterative refinement  is provided because exact form of original matrix
    7121             : is not known to subroutine. Use CMatrixSolve or CMatrixMixedSolve  if  you
    7122             : need iterative refinement.
    7123             : 
    7124             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    7125             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    7126             :            ! which  results  in  significant  performance   penalty   when
    7127             :            ! compared with "fast"  version  which  just  calls  triangular
    7128             :            ! solver.
    7129             :            !
    7130             :            ! This performance penalty is especially apparent when you  use
    7131             :            ! ALGLIB parallel capabilities (condition number estimation  is
    7132             :            ! inherently  sequential).  It   also   becomes significant for
    7133             :            ! small-scale problems.
    7134             :            !
    7135             :            ! In such cases we strongly recommend you to use faster solver,
    7136             :            ! CMatrixLUSolveMFast() function.
    7137             : 
    7138             :   ! COMMERCIAL EDITION OF ALGLIB:
    7139             :   ! 
    7140             :   ! Commercial Edition of ALGLIB includes following important improvements
    7141             :   ! of this function:
    7142             :   ! * high-performance native backend with same C# interface (C# version)
    7143             :   ! * multithreading support (C++ and C# versions)
    7144             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    7145             :   !   (C++ and C# versions, x86/x64 platform)
    7146             :   ! 
    7147             :   ! We recommend you to read 'Working with commercial version' section  of
    7148             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    7149             :   ! related features provided by commercial edition of ALGLIB.
    7150             : 
    7151             : INPUT PARAMETERS
    7152             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    7153             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    7154             :     N       -   size of A
    7155             :     B       -   array[0..N-1,0..M-1], right part
    7156             :     M       -   right part size
    7157             : 
    7158             : OUTPUT PARAMETERS
    7159             :     Info    -   return code:
    7160             :                 * -3    matrix is very badly conditioned or exactly singular.
    7161             :                 * -1    N<=0 was passed
    7162             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    7163             :                         check R1/RInf parameters for condition numbers).
    7164             :     Rep     -   additional report, following fields are set:
    7165             :                 * rep.r1    condition number in 1-norm
    7166             :                 * rep.rinf  condition number in inf-norm
    7167             :     X       -   array[N,M], it contains:
    7168             :                 * info>0    =>  solution
    7169             :                 * info=-3   =>  filled by zeros
    7170             : 
    7171             :   -- ALGLIB --
    7172             :      Copyright 27.01.2010 by Bochkanov Sergey
    7173             : *************************************************************************/
    7174           0 : void cmatrixlusolvem(/* Complex */ ae_matrix* lua,
    7175             :      /* Integer */ ae_vector* p,
    7176             :      ae_int_t n,
    7177             :      /* Complex */ ae_matrix* b,
    7178             :      ae_int_t m,
    7179             :      ae_int_t* info,
    7180             :      densesolverreport* rep,
    7181             :      /* Complex */ ae_matrix* x,
    7182             :      ae_state *_state)
    7183             : {
    7184             :     ae_frame _frame_block;
    7185             :     ae_matrix emptya;
    7186             : 
    7187           0 :     ae_frame_make(_state, &_frame_block);
    7188           0 :     memset(&emptya, 0, sizeof(emptya));
    7189           0 :     *info = 0;
    7190           0 :     _densesolverreport_clear(rep);
    7191           0 :     ae_matrix_clear(x);
    7192           0 :     ae_matrix_init(&emptya, 0, 0, DT_COMPLEX, _state, ae_true);
    7193             : 
    7194             :     
    7195             :     /*
    7196             :      * prepare: check inputs, allocate space...
    7197             :      */
    7198           0 :     if( n<=0||m<=0 )
    7199             :     {
    7200           0 :         *info = -1;
    7201           0 :         ae_frame_leave(_state);
    7202           0 :         return;
    7203             :     }
    7204             :     
    7205             :     /*
    7206             :      * solve
    7207             :      */
    7208           0 :     directdensesolvers_cmatrixlusolveinternal(lua, p, n, &emptya, ae_false, b, m, info, rep, x, _state);
    7209           0 :     ae_frame_leave(_state);
    7210             : }
    7211             : 
    7212             : 
    7213             : /*************************************************************************
    7214             : Dense solver for A*X=B with N*N complex A given by its  LU  decomposition,
    7215             : and N*M matrices X and B (multiple  right  sides).  "Fast-but-lightweight"
    7216             : version of the solver.
    7217             : 
    7218             : Algorithm features:
    7219             : * O(M*N^2) complexity
    7220             : * no additional time-consuming features
    7221             : 
    7222             :   ! COMMERCIAL EDITION OF ALGLIB:
    7223             :   ! 
    7224             :   ! Commercial Edition of ALGLIB includes following important improvements
    7225             :   ! of this function:
    7226             :   ! * high-performance native backend with same C# interface (C# version)
    7227             :   ! * multithreading support (C++ and C# versions)
    7228             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    7229             :   !   (C++ and C# versions, x86/x64 platform)
    7230             :   ! 
    7231             :   ! We recommend you to read 'Working with commercial version' section  of
    7232             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    7233             :   ! related features provided by commercial edition of ALGLIB.
    7234             : 
    7235             : INPUT PARAMETERS
    7236             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, RMatrixLU result
    7237             :     P       -   array[0..N-1], pivots array, RMatrixLU result
    7238             :     N       -   size of A
    7239             :     B       -   array[0..N-1,0..M-1], right part
    7240             :     M       -   right part size
    7241             : 
    7242             : OUTPUT PARAMETERS
    7243             :     Info    -   return code:
    7244             :                 * -3    matrix is exactly singular (ill conditioned matrices
    7245             :                         are not recognized).
    7246             :                 * -1    N<=0 was passed
    7247             :                 *  1    task is solved 
    7248             :     B       -   array[N,M]:
    7249             :                 * info>0    =>  overwritten by solution
    7250             :                 * info=-3   =>  filled by zeros
    7251             : 
    7252             : 
    7253             :   -- ALGLIB --
    7254             :      Copyright 27.01.2010 by Bochkanov Sergey
    7255             : *************************************************************************/
    7256           0 : void cmatrixlusolvemfast(/* Complex */ ae_matrix* lua,
    7257             :      /* Integer */ ae_vector* p,
    7258             :      ae_int_t n,
    7259             :      /* Complex */ ae_matrix* b,
    7260             :      ae_int_t m,
    7261             :      ae_int_t* info,
    7262             :      ae_state *_state)
    7263             : {
    7264             :     ae_complex v;
    7265             :     ae_int_t i;
    7266             :     ae_int_t j;
    7267             :     ae_int_t k;
    7268             : 
    7269           0 :     *info = 0;
    7270             : 
    7271             :     
    7272             :     /*
    7273             :      * Check for exact degeneracy
    7274             :      */
    7275           0 :     if( n<=0||m<=0 )
    7276             :     {
    7277           0 :         *info = -1;
    7278           0 :         return;
    7279             :     }
    7280           0 :     for(i=0; i<=n-1; i++)
    7281             :     {
    7282           0 :         if( ae_c_eq_d(lua->ptr.pp_complex[i][i],(double)(0)) )
    7283             :         {
    7284           0 :             for(j=0; j<=n-1; j++)
    7285             :             {
    7286           0 :                 for(k=0; k<=m-1; k++)
    7287             :                 {
    7288           0 :                     b->ptr.pp_complex[j][k] = ae_complex_from_d(0.0);
    7289             :                 }
    7290             :             }
    7291           0 :             *info = -3;
    7292           0 :             return;
    7293             :         }
    7294             :     }
    7295             :     
    7296             :     /*
    7297             :      * Solve with TRSM()
    7298             :      */
    7299           0 :     for(i=0; i<=n-1; i++)
    7300             :     {
    7301           0 :         if( p->ptr.p_int[i]!=i )
    7302             :         {
    7303           0 :             for(j=0; j<=m-1; j++)
    7304             :             {
    7305           0 :                 v = b->ptr.pp_complex[i][j];
    7306           0 :                 b->ptr.pp_complex[i][j] = b->ptr.pp_complex[p->ptr.p_int[i]][j];
    7307           0 :                 b->ptr.pp_complex[p->ptr.p_int[i]][j] = v;
    7308             :             }
    7309             :         }
    7310             :     }
    7311           0 :     cmatrixlefttrsm(n, m, lua, 0, 0, ae_false, ae_true, 0, b, 0, 0, _state);
    7312           0 :     cmatrixlefttrsm(n, m, lua, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    7313           0 :     *info = 1;
    7314             : }
    7315             : 
    7316             : 
    7317             : /*************************************************************************
    7318             : Complex dense linear solver for A*x=b with complex N*N A  given  by its LU
    7319             : decomposition and N*1 vectors x and b. This is  "slow-but-robust"  version
    7320             : of  the  complex  linear  solver  with  additional  features   which   add
    7321             : significant performance overhead. Faster version  is  CMatrixLUSolveFast()
    7322             : function.
    7323             : 
    7324             : Algorithm features:
    7325             : * automatic detection of degenerate cases
    7326             : * O(N^2) complexity
    7327             : * condition number estimation
    7328             : 
    7329             : No iterative refinement is provided because exact form of original matrix
    7330             : is not known to subroutine. Use CMatrixSolve or CMatrixMixedSolve  if  you
    7331             : need iterative refinement.
    7332             : 
    7333             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    7334             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    7335             :            ! which results in 10-15x  performance  penalty  when  compared
    7336             :            ! with "fast" version which just calls triangular solver.
    7337             :            !
    7338             :            ! This performance penalty is insignificant  when compared with
    7339             :            ! cost of large LU decomposition.  However,  if you  call  this
    7340             :            ! function many times for the same  left  side,  this  overhead
    7341             :            ! BECOMES significant. It  also  becomes significant for small-
    7342             :            ! scale problems.
    7343             :            !
    7344             :            ! In such cases we strongly recommend you to use faster solver,
    7345             :            ! CMatrixLUSolveFast() function.
    7346             : 
    7347             : INPUT PARAMETERS
    7348             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    7349             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    7350             :     N       -   size of A
    7351             :     B       -   array[0..N-1], right part
    7352             : 
    7353             : OUTPUT PARAMETERS
    7354             :     Info    -   return code:
    7355             :                 * -3    matrix is very badly conditioned or exactly singular.
    7356             :                 * -1    N<=0 was passed
    7357             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    7358             :                         check R1/RInf parameters for condition numbers).
    7359             :     Rep     -   additional report, following fields are set:
    7360             :                 * rep.r1    condition number in 1-norm
    7361             :                 * rep.rinf  condition number in inf-norm
    7362             :     X       -   array[N], it contains:
    7363             :                 * info>0    =>  solution
    7364             :                 * info=-3   =>  filled by zeros
    7365             : 
    7366             :   -- ALGLIB --
    7367             :      Copyright 27.01.2010 by Bochkanov Sergey
    7368             : *************************************************************************/
    7369           0 : void cmatrixlusolve(/* Complex */ ae_matrix* lua,
    7370             :      /* Integer */ ae_vector* p,
    7371             :      ae_int_t n,
    7372             :      /* Complex */ ae_vector* b,
    7373             :      ae_int_t* info,
    7374             :      densesolverreport* rep,
    7375             :      /* Complex */ ae_vector* x,
    7376             :      ae_state *_state)
    7377             : {
    7378             :     ae_frame _frame_block;
    7379             :     ae_matrix bm;
    7380             :     ae_matrix xm;
    7381             : 
    7382           0 :     ae_frame_make(_state, &_frame_block);
    7383           0 :     memset(&bm, 0, sizeof(bm));
    7384           0 :     memset(&xm, 0, sizeof(xm));
    7385           0 :     *info = 0;
    7386           0 :     _densesolverreport_clear(rep);
    7387           0 :     ae_vector_clear(x);
    7388           0 :     ae_matrix_init(&bm, 0, 0, DT_COMPLEX, _state, ae_true);
    7389           0 :     ae_matrix_init(&xm, 0, 0, DT_COMPLEX, _state, ae_true);
    7390             : 
    7391           0 :     if( n<=0 )
    7392             :     {
    7393           0 :         *info = -1;
    7394           0 :         ae_frame_leave(_state);
    7395           0 :         return;
    7396             :     }
    7397           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    7398           0 :     ae_v_cmove(&bm.ptr.pp_complex[0][0], bm.stride, &b->ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    7399           0 :     cmatrixlusolvem(lua, p, n, &bm, 1, info, rep, &xm, _state);
    7400           0 :     ae_vector_set_length(x, n, _state);
    7401           0 :     ae_v_cmove(&x->ptr.p_complex[0], 1, &xm.ptr.pp_complex[0][0], xm.stride, "N", ae_v_len(0,n-1));
    7402           0 :     ae_frame_leave(_state);
    7403             : }
    7404             : 
    7405             : 
    7406             : /*************************************************************************
    7407             : Complex dense linear solver for A*x=b with N*N complex A given by  its  LU
    7408             : decomposition and N*1 vectors x and b. This is  fast  lightweight  version
    7409             : of solver, which is significantly faster than CMatrixLUSolve(),  but  does
    7410             : not provide additional information (like condition numbers).
    7411             : 
    7412             : Algorithm features:
    7413             : * O(N^2) complexity
    7414             : * no additional time-consuming features, just triangular solver
    7415             : 
    7416             : INPUT PARAMETERS
    7417             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    7418             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    7419             :     N       -   size of A
    7420             :     B       -   array[0..N-1], right part
    7421             : 
    7422             : OUTPUT PARAMETERS
    7423             :     Info    -   return code:
    7424             :                 * -3    matrix is exactly singular (ill conditioned matrices
    7425             :                         are not recognized).
    7426             :                 * -1    N<=0 was passed
    7427             :                 *  1    task is solved 
    7428             :     B       -   array[N]:
    7429             :                 * info>0    =>  overwritten by solution
    7430             :                 * info=-3   =>  filled by zeros
    7431             :     
    7432             : NOTE: unlike  CMatrixLUSolve(),  this   function   does   NOT   check  for
    7433             :       near-degeneracy of input matrix. It  checks  for  EXACT  degeneracy,
    7434             :       because this check is easy to do. However,  very  badly  conditioned
    7435             :       matrices may went unnoticed.
    7436             : 
    7437             : 
    7438             :   -- ALGLIB --
    7439             :      Copyright 27.01.2010 by Bochkanov Sergey
    7440             : *************************************************************************/
    7441           0 : void cmatrixlusolvefast(/* Complex */ ae_matrix* lua,
    7442             :      /* Integer */ ae_vector* p,
    7443             :      ae_int_t n,
    7444             :      /* Complex */ ae_vector* b,
    7445             :      ae_int_t* info,
    7446             :      ae_state *_state)
    7447             : {
    7448             :     ae_int_t i;
    7449             :     ae_int_t j;
    7450             : 
    7451           0 :     *info = 0;
    7452             : 
    7453           0 :     if( n<=0 )
    7454             :     {
    7455           0 :         *info = -1;
    7456           0 :         return;
    7457             :     }
    7458           0 :     for(i=0; i<=n-1; i++)
    7459             :     {
    7460           0 :         if( ae_c_eq_d(lua->ptr.pp_complex[i][i],(double)(0)) )
    7461             :         {
    7462           0 :             for(j=0; j<=n-1; j++)
    7463             :             {
    7464           0 :                 b->ptr.p_complex[j] = ae_complex_from_d(0.0);
    7465             :             }
    7466           0 :             *info = -3;
    7467           0 :             return;
    7468             :         }
    7469             :     }
    7470           0 :     directdensesolvers_cbasiclusolve(lua, p, n, b, _state);
    7471           0 :     *info = 1;
    7472             : }
    7473             : 
    7474             : 
    7475             : /*************************************************************************
    7476             : Dense solver. Same as RMatrixMixedSolveM(), but for complex matrices.
    7477             : 
    7478             : Algorithm features:
    7479             : * automatic detection of degenerate cases
    7480             : * condition number estimation
    7481             : * iterative refinement
    7482             : * O(M*N^2) complexity
    7483             : 
    7484             : INPUT PARAMETERS
    7485             :     A       -   array[0..N-1,0..N-1], system matrix
    7486             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    7487             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    7488             :     N       -   size of A
    7489             :     B       -   array[0..N-1,0..M-1], right part
    7490             :     M       -   right part size
    7491             : 
    7492             : OUTPUT PARAMETERS
    7493             :     Info    -   return code:
    7494             :                 * -3    matrix is very badly conditioned or exactly singular.
    7495             :                 * -1    N<=0 was passed
    7496             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    7497             :                         check R1/RInf parameters for condition numbers).
    7498             :     Rep     -   additional report, following fields are set:
    7499             :                 * rep.r1    condition number in 1-norm
    7500             :                 * rep.rinf  condition number in inf-norm
    7501             :     X       -   array[N,M], it contains:
    7502             :                 * info>0    =>  solution
    7503             :                 * info=-3   =>  filled by zeros
    7504             : 
    7505             :   -- ALGLIB --
    7506             :      Copyright 27.01.2010 by Bochkanov Sergey
    7507             : *************************************************************************/
    7508           0 : void cmatrixmixedsolvem(/* Complex */ ae_matrix* a,
    7509             :      /* Complex */ ae_matrix* lua,
    7510             :      /* Integer */ ae_vector* p,
    7511             :      ae_int_t n,
    7512             :      /* Complex */ ae_matrix* b,
    7513             :      ae_int_t m,
    7514             :      ae_int_t* info,
    7515             :      densesolverreport* rep,
    7516             :      /* Complex */ ae_matrix* x,
    7517             :      ae_state *_state)
    7518             : {
    7519             : 
    7520           0 :     *info = 0;
    7521           0 :     _densesolverreport_clear(rep);
    7522           0 :     ae_matrix_clear(x);
    7523             : 
    7524             :     
    7525             :     /*
    7526             :      * prepare: check inputs, allocate space...
    7527             :      */
    7528           0 :     if( n<=0||m<=0 )
    7529             :     {
    7530           0 :         *info = -1;
    7531           0 :         return;
    7532             :     }
    7533             :     
    7534             :     /*
    7535             :      * solve
    7536             :      */
    7537           0 :     directdensesolvers_cmatrixlusolveinternal(lua, p, n, a, ae_true, b, m, info, rep, x, _state);
    7538             : }
    7539             : 
    7540             : 
    7541             : /*************************************************************************
    7542             : Dense solver. Same as RMatrixMixedSolve(), but for complex matrices.
    7543             : 
    7544             : Algorithm features:
    7545             : * automatic detection of degenerate cases
    7546             : * condition number estimation
    7547             : * iterative refinement
    7548             : * O(N^2) complexity
    7549             : 
    7550             : INPUT PARAMETERS
    7551             :     A       -   array[0..N-1,0..N-1], system matrix
    7552             :     LUA     -   array[0..N-1,0..N-1], LU decomposition, CMatrixLU result
    7553             :     P       -   array[0..N-1], pivots array, CMatrixLU result
    7554             :     N       -   size of A
    7555             :     B       -   array[0..N-1], right part
    7556             : 
    7557             : OUTPUT PARAMETERS
    7558             :     Info    -   return code:
    7559             :                 * -3    matrix is very badly conditioned or exactly singular.
    7560             :                 * -1    N<=0 was passed
    7561             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    7562             :                         check R1/RInf parameters for condition numbers).
    7563             :     Rep     -   additional report, following fields are set:
    7564             :                 * rep.r1    condition number in 1-norm
    7565             :                 * rep.rinf  condition number in inf-norm
    7566             :     X       -   array[N], it contains:
    7567             :                 * info>0    =>  solution
    7568             :                 * info=-3   =>  filled by zeros
    7569             : 
    7570             :   -- ALGLIB --
    7571             :      Copyright 27.01.2010 by Bochkanov Sergey
    7572             : *************************************************************************/
    7573           0 : void cmatrixmixedsolve(/* Complex */ ae_matrix* a,
    7574             :      /* Complex */ ae_matrix* lua,
    7575             :      /* Integer */ ae_vector* p,
    7576             :      ae_int_t n,
    7577             :      /* Complex */ ae_vector* b,
    7578             :      ae_int_t* info,
    7579             :      densesolverreport* rep,
    7580             :      /* Complex */ ae_vector* x,
    7581             :      ae_state *_state)
    7582             : {
    7583             :     ae_frame _frame_block;
    7584             :     ae_matrix bm;
    7585             :     ae_matrix xm;
    7586             : 
    7587           0 :     ae_frame_make(_state, &_frame_block);
    7588           0 :     memset(&bm, 0, sizeof(bm));
    7589           0 :     memset(&xm, 0, sizeof(xm));
    7590           0 :     *info = 0;
    7591           0 :     _densesolverreport_clear(rep);
    7592           0 :     ae_vector_clear(x);
    7593           0 :     ae_matrix_init(&bm, 0, 0, DT_COMPLEX, _state, ae_true);
    7594           0 :     ae_matrix_init(&xm, 0, 0, DT_COMPLEX, _state, ae_true);
    7595             : 
    7596           0 :     if( n<=0 )
    7597             :     {
    7598           0 :         *info = -1;
    7599           0 :         ae_frame_leave(_state);
    7600           0 :         return;
    7601             :     }
    7602           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    7603           0 :     ae_v_cmove(&bm.ptr.pp_complex[0][0], bm.stride, &b->ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    7604           0 :     cmatrixmixedsolvem(a, lua, p, n, &bm, 1, info, rep, &xm, _state);
    7605           0 :     ae_vector_set_length(x, n, _state);
    7606           0 :     ae_v_cmove(&x->ptr.p_complex[0], 1, &xm.ptr.pp_complex[0][0], xm.stride, "N", ae_v_len(0,n-1));
    7607           0 :     ae_frame_leave(_state);
    7608             : }
    7609             : 
    7610             : 
    7611             : /*************************************************************************
    7612             : Dense solver for A*X=B with N*N symmetric positive definite matrix A,  and
    7613             : N*M vectors X and B. It is "slow-but-feature-rich" version of the solver.
    7614             : 
    7615             : Algorithm features:
    7616             : * automatic detection of degenerate cases
    7617             : * condition number estimation
    7618             : * O(N^3+M*N^2) complexity
    7619             : * matrix is represented by its upper or lower triangle
    7620             : 
    7621             : No iterative refinement is provided because such partial representation of
    7622             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    7623             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    7624             : need iterative refinement.
    7625             : 
    7626             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    7627             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    7628             :            ! which  results  in  significant   performance   penalty  when
    7629             :            ! compared with "fast" version  which  just  performs  Cholesky
    7630             :            ! decomposition and calls triangular solver.
    7631             :            !
    7632             :            ! This  performance  penalty  is  especially  visible  in   the
    7633             :            ! multithreaded mode, because both condition number  estimation
    7634             :            ! and   iterative    refinement   are   inherently   sequential
    7635             :            ! calculations.
    7636             :            !
    7637             :            ! Thus, if you need high performance and if you are pretty sure
    7638             :            ! that your system is well conditioned, we  strongly  recommend
    7639             :            ! you to use faster solver, SPDMatrixSolveMFast() function.
    7640             : 
    7641             :   ! COMMERCIAL EDITION OF ALGLIB:
    7642             :   ! 
    7643             :   ! Commercial Edition of ALGLIB includes following important improvements
    7644             :   ! of this function:
    7645             :   ! * high-performance native backend with same C# interface (C# version)
    7646             :   ! * multithreading support (C++ and C# versions)
    7647             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    7648             :   !   (C++ and C# versions, x86/x64 platform)
    7649             :   ! 
    7650             :   ! We recommend you to read 'Working with commercial version' section  of
    7651             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    7652             :   ! related features provided by commercial edition of ALGLIB.
    7653             : 
    7654             : INPUT PARAMETERS
    7655             :     A       -   array[0..N-1,0..N-1], system matrix
    7656             :     N       -   size of A
    7657             :     IsUpper -   what half of A is provided
    7658             :     B       -   array[0..N-1,0..M-1], right part
    7659             :     M       -   right part size
    7660             : 
    7661             : OUTPUT PARAMETERS
    7662             :     Info    -   return code:
    7663             :                 * -3    matrix is very badly conditioned or non-SPD.
    7664             :                 * -1    N<=0 was passed
    7665             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    7666             :                         check R1/RInf parameters for condition numbers).
    7667             :     Rep     -   additional report, following fields are set:
    7668             :                 * rep.r1    condition number in 1-norm
    7669             :                 * rep.rinf  condition number in inf-norm
    7670             :     X       -   array[N,M], it contains:
    7671             :                 * info>0    =>  solution
    7672             :                 * info=-3   =>  filled by zeros
    7673             : 
    7674             :   -- ALGLIB --
    7675             :      Copyright 27.01.2010 by Bochkanov Sergey
    7676             : *************************************************************************/
    7677           0 : void spdmatrixsolvem(/* Real    */ ae_matrix* a,
    7678             :      ae_int_t n,
    7679             :      ae_bool isupper,
    7680             :      /* Real    */ ae_matrix* b,
    7681             :      ae_int_t m,
    7682             :      ae_int_t* info,
    7683             :      densesolverreport* rep,
    7684             :      /* Real    */ ae_matrix* x,
    7685             :      ae_state *_state)
    7686             : {
    7687             :     ae_frame _frame_block;
    7688             :     ae_matrix da;
    7689             :     ae_int_t i;
    7690             :     ae_int_t j;
    7691             :     ae_int_t j1;
    7692             :     ae_int_t j2;
    7693             : 
    7694           0 :     ae_frame_make(_state, &_frame_block);
    7695           0 :     memset(&da, 0, sizeof(da));
    7696           0 :     *info = 0;
    7697           0 :     _densesolverreport_clear(rep);
    7698           0 :     ae_matrix_clear(x);
    7699           0 :     ae_matrix_init(&da, 0, 0, DT_REAL, _state, ae_true);
    7700             : 
    7701             :     
    7702             :     /*
    7703             :      * prepare: check inputs, allocate space...
    7704             :      */
    7705           0 :     if( n<=0||m<=0 )
    7706             :     {
    7707           0 :         *info = -1;
    7708           0 :         ae_frame_leave(_state);
    7709           0 :         return;
    7710             :     }
    7711           0 :     ae_matrix_set_length(&da, n, n, _state);
    7712             :     
    7713             :     /*
    7714             :      * factorize
    7715             :      * solve
    7716             :      */
    7717           0 :     for(i=0; i<=n-1; i++)
    7718             :     {
    7719           0 :         if( isupper )
    7720             :         {
    7721           0 :             j1 = i;
    7722           0 :             j2 = n-1;
    7723             :         }
    7724             :         else
    7725             :         {
    7726           0 :             j1 = 0;
    7727           0 :             j2 = i;
    7728             :         }
    7729           0 :         ae_v_move(&da.ptr.pp_double[i][j1], 1, &a->ptr.pp_double[i][j1], 1, ae_v_len(j1,j2));
    7730             :     }
    7731           0 :     if( !spdmatrixcholesky(&da, n, isupper, _state) )
    7732             :     {
    7733           0 :         ae_matrix_set_length(x, n, m, _state);
    7734           0 :         for(i=0; i<=n-1; i++)
    7735             :         {
    7736           0 :             for(j=0; j<=m-1; j++)
    7737             :             {
    7738           0 :                 x->ptr.pp_double[i][j] = (double)(0);
    7739             :             }
    7740             :         }
    7741           0 :         rep->r1 = (double)(0);
    7742           0 :         rep->rinf = (double)(0);
    7743           0 :         *info = -3;
    7744           0 :         ae_frame_leave(_state);
    7745           0 :         return;
    7746             :     }
    7747           0 :     *info = 1;
    7748           0 :     directdensesolvers_spdmatrixcholeskysolveinternal(&da, n, isupper, a, ae_true, b, m, info, rep, x, _state);
    7749           0 :     ae_frame_leave(_state);
    7750             : }
    7751             : 
    7752             : 
    7753             : /*************************************************************************
    7754             : Dense solver for A*X=B with N*N symmetric positive definite matrix A,  and
    7755             : N*M vectors X and B. It is "fast-but-lightweight" version of the solver.
    7756             : 
    7757             : Algorithm features:
    7758             : * O(N^3+M*N^2) complexity
    7759             : * matrix is represented by its upper or lower triangle
    7760             : * no additional time consuming features
    7761             : 
    7762             :   ! COMMERCIAL EDITION OF ALGLIB:
    7763             :   ! 
    7764             :   ! Commercial Edition of ALGLIB includes following important improvements
    7765             :   ! of this function:
    7766             :   ! * high-performance native backend with same C# interface (C# version)
    7767             :   ! * multithreading support (C++ and C# versions)
    7768             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    7769             :   !   (C++ and C# versions, x86/x64 platform)
    7770             :   ! 
    7771             :   ! We recommend you to read 'Working with commercial version' section  of
    7772             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    7773             :   ! related features provided by commercial edition of ALGLIB.
    7774             : 
    7775             : INPUT PARAMETERS
    7776             :     A       -   array[0..N-1,0..N-1], system matrix
    7777             :     N       -   size of A
    7778             :     IsUpper -   what half of A is provided
    7779             :     B       -   array[0..N-1,0..M-1], right part
    7780             :     M       -   right part size
    7781             : 
    7782             : OUTPUT PARAMETERS
    7783             :     Info    -   return code:
    7784             :                 * -3    A is is exactly singular
    7785             :                 * -1    N<=0 was passed
    7786             :                 *  1    task was solved
    7787             :     B       -   array[N,M], it contains:
    7788             :                 * info>0    =>  solution
    7789             :                 * info=-3   =>  filled by zeros
    7790             : 
    7791             :   -- ALGLIB --
    7792             :      Copyright 17.03.2015 by Bochkanov Sergey
    7793             : *************************************************************************/
    7794           0 : void spdmatrixsolvemfast(/* Real    */ ae_matrix* a,
    7795             :      ae_int_t n,
    7796             :      ae_bool isupper,
    7797             :      /* Real    */ ae_matrix* b,
    7798             :      ae_int_t m,
    7799             :      ae_int_t* info,
    7800             :      ae_state *_state)
    7801             : {
    7802             :     ae_frame _frame_block;
    7803             :     ae_matrix _a;
    7804             :     ae_int_t i;
    7805             :     ae_int_t j;
    7806             : 
    7807           0 :     ae_frame_make(_state, &_frame_block);
    7808           0 :     memset(&_a, 0, sizeof(_a));
    7809           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    7810           0 :     a = &_a;
    7811           0 :     *info = 0;
    7812             : 
    7813           0 :     *info = 1;
    7814           0 :     if( n<=0 )
    7815             :     {
    7816           0 :         *info = -1;
    7817           0 :         ae_frame_leave(_state);
    7818           0 :         return;
    7819             :     }
    7820           0 :     if( !spdmatrixcholesky(a, n, isupper, _state) )
    7821             :     {
    7822           0 :         for(i=0; i<=n-1; i++)
    7823             :         {
    7824           0 :             for(j=0; j<=m-1; j++)
    7825             :             {
    7826           0 :                 b->ptr.pp_double[i][j] = 0.0;
    7827             :             }
    7828             :         }
    7829           0 :         *info = -3;
    7830           0 :         ae_frame_leave(_state);
    7831           0 :         return;
    7832             :     }
    7833           0 :     if( isupper )
    7834             :     {
    7835           0 :         rmatrixlefttrsm(n, m, a, 0, 0, ae_true, ae_false, 1, b, 0, 0, _state);
    7836           0 :         rmatrixlefttrsm(n, m, a, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    7837             :     }
    7838             :     else
    7839             :     {
    7840           0 :         rmatrixlefttrsm(n, m, a, 0, 0, ae_false, ae_false, 0, b, 0, 0, _state);
    7841           0 :         rmatrixlefttrsm(n, m, a, 0, 0, ae_false, ae_false, 1, b, 0, 0, _state);
    7842             :     }
    7843           0 :     ae_frame_leave(_state);
    7844             : }
    7845             : 
    7846             : 
    7847             : /*************************************************************************
    7848             : Dense linear solver for A*x=b with N*N real  symmetric  positive  definite
    7849             : matrix A,  N*1 vectors x and b.  "Slow-but-feature-rich"  version  of  the
    7850             : solver.
    7851             : 
    7852             : Algorithm features:
    7853             : * automatic detection of degenerate cases
    7854             : * condition number estimation
    7855             : * O(N^3) complexity
    7856             : * matrix is represented by its upper or lower triangle
    7857             : 
    7858             : No iterative refinement is provided because such partial representation of
    7859             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    7860             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    7861             : need iterative refinement.
    7862             : 
    7863             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    7864             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    7865             :            ! which  results  in  significant   performance   penalty  when
    7866             :            ! compared with "fast" version  which  just  performs  Cholesky
    7867             :            ! decomposition and calls triangular solver.
    7868             :            !
    7869             :            ! This  performance  penalty  is  especially  visible  in   the
    7870             :            ! multithreaded mode, because both condition number  estimation
    7871             :            ! and   iterative    refinement   are   inherently   sequential
    7872             :            ! calculations.
    7873             :            !
    7874             :            ! Thus, if you need high performance and if you are pretty sure
    7875             :            ! that your system is well conditioned, we  strongly  recommend
    7876             :            ! you to use faster solver, SPDMatrixSolveFast() function.
    7877             : 
    7878             :   ! COMMERCIAL EDITION OF ALGLIB:
    7879             :   ! 
    7880             :   ! Commercial Edition of ALGLIB includes following important improvements
    7881             :   ! of this function:
    7882             :   ! * high-performance native backend with same C# interface (C# version)
    7883             :   ! * multithreading support (C++ and C# versions)
    7884             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    7885             :   !   (C++ and C# versions, x86/x64 platform)
    7886             :   ! 
    7887             :   ! We recommend you to read 'Working with commercial version' section  of
    7888             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    7889             :   ! related features provided by commercial edition of ALGLIB.
    7890             : 
    7891             : INPUT PARAMETERS
    7892             :     A       -   array[0..N-1,0..N-1], system matrix
    7893             :     N       -   size of A
    7894             :     IsUpper -   what half of A is provided
    7895             :     B       -   array[0..N-1], right part
    7896             : 
    7897             : OUTPUT PARAMETERS
    7898             :     Info    -   return code:
    7899             :                 * -3    matrix is very badly conditioned or non-SPD.
    7900             :                 * -1    N<=0 was passed
    7901             :                 *  1    task is solved (but matrix A may be ill-conditioned,
    7902             :                         check R1/RInf parameters for condition numbers).
    7903             :     Rep     -   additional report, following fields are set:
    7904             :                 * rep.r1    condition number in 1-norm
    7905             :                 * rep.rinf  condition number in inf-norm
    7906             :     X       -   array[N], it contains:
    7907             :                 * info>0    =>  solution
    7908             :                 * info=-3   =>  filled by zeros
    7909             : 
    7910             :   -- ALGLIB --
    7911             :      Copyright 27.01.2010 by Bochkanov Sergey
    7912             : *************************************************************************/
    7913           0 : void spdmatrixsolve(/* Real    */ ae_matrix* a,
    7914             :      ae_int_t n,
    7915             :      ae_bool isupper,
    7916             :      /* Real    */ ae_vector* b,
    7917             :      ae_int_t* info,
    7918             :      densesolverreport* rep,
    7919             :      /* Real    */ ae_vector* x,
    7920             :      ae_state *_state)
    7921             : {
    7922             :     ae_frame _frame_block;
    7923             :     ae_matrix bm;
    7924             :     ae_matrix xm;
    7925             : 
    7926           0 :     ae_frame_make(_state, &_frame_block);
    7927           0 :     memset(&bm, 0, sizeof(bm));
    7928           0 :     memset(&xm, 0, sizeof(xm));
    7929           0 :     *info = 0;
    7930           0 :     _densesolverreport_clear(rep);
    7931           0 :     ae_vector_clear(x);
    7932           0 :     ae_matrix_init(&bm, 0, 0, DT_REAL, _state, ae_true);
    7933           0 :     ae_matrix_init(&xm, 0, 0, DT_REAL, _state, ae_true);
    7934             : 
    7935           0 :     if( n<=0 )
    7936             :     {
    7937           0 :         *info = -1;
    7938           0 :         ae_frame_leave(_state);
    7939           0 :         return;
    7940             :     }
    7941           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    7942           0 :     ae_v_move(&bm.ptr.pp_double[0][0], bm.stride, &b->ptr.p_double[0], 1, ae_v_len(0,n-1));
    7943           0 :     spdmatrixsolvem(a, n, isupper, &bm, 1, info, rep, &xm, _state);
    7944           0 :     ae_vector_set_length(x, n, _state);
    7945           0 :     ae_v_move(&x->ptr.p_double[0], 1, &xm.ptr.pp_double[0][0], xm.stride, ae_v_len(0,n-1));
    7946           0 :     ae_frame_leave(_state);
    7947             : }
    7948             : 
    7949             : 
    7950             : /*************************************************************************
    7951             : Dense linear solver for A*x=b with N*N real  symmetric  positive  definite
    7952             : matrix A,  N*1 vectors x and  b.  "Fast-but-lightweight"  version  of  the
    7953             : solver.
    7954             : 
    7955             : Algorithm features:
    7956             : * O(N^3) complexity
    7957             : * matrix is represented by its upper or lower triangle
    7958             : * no additional time consuming features like condition number estimation
    7959             : 
    7960             :   ! COMMERCIAL EDITION OF ALGLIB:
    7961             :   ! 
    7962             :   ! Commercial Edition of ALGLIB includes following important improvements
    7963             :   ! of this function:
    7964             :   ! * high-performance native backend with same C# interface (C# version)
    7965             :   ! * multithreading support (C++ and C# versions)
    7966             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    7967             :   !   (C++ and C# versions, x86/x64 platform)
    7968             :   ! 
    7969             :   ! We recommend you to read 'Working with commercial version' section  of
    7970             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    7971             :   ! related features provided by commercial edition of ALGLIB.
    7972             : 
    7973             : INPUT PARAMETERS
    7974             :     A       -   array[0..N-1,0..N-1], system matrix
    7975             :     N       -   size of A
    7976             :     IsUpper -   what half of A is provided
    7977             :     B       -   array[0..N-1], right part
    7978             : 
    7979             : OUTPUT PARAMETERS
    7980             :     Info    -   return code:
    7981             :                 * -3    A is is exactly singular or non-SPD
    7982             :                 * -1    N<=0 was passed
    7983             :                 *  1    task was solved
    7984             :     B       -   array[N], it contains:
    7985             :                 * info>0    =>  solution
    7986             :                 * info=-3   =>  filled by zeros
    7987             : 
    7988             :   -- ALGLIB --
    7989             :      Copyright 17.03.2015 by Bochkanov Sergey
    7990             : *************************************************************************/
    7991           0 : void spdmatrixsolvefast(/* Real    */ ae_matrix* a,
    7992             :      ae_int_t n,
    7993             :      ae_bool isupper,
    7994             :      /* Real    */ ae_vector* b,
    7995             :      ae_int_t* info,
    7996             :      ae_state *_state)
    7997             : {
    7998             :     ae_frame _frame_block;
    7999             :     ae_matrix _a;
    8000             :     ae_int_t i;
    8001             : 
    8002           0 :     ae_frame_make(_state, &_frame_block);
    8003           0 :     memset(&_a, 0, sizeof(_a));
    8004           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    8005           0 :     a = &_a;
    8006           0 :     *info = 0;
    8007             : 
    8008           0 :     *info = 1;
    8009           0 :     if( n<=0 )
    8010             :     {
    8011           0 :         *info = -1;
    8012           0 :         ae_frame_leave(_state);
    8013           0 :         return;
    8014             :     }
    8015           0 :     if( !spdmatrixcholesky(a, n, isupper, _state) )
    8016             :     {
    8017           0 :         for(i=0; i<=n-1; i++)
    8018             :         {
    8019           0 :             b->ptr.p_double[i] = 0.0;
    8020             :         }
    8021           0 :         *info = -3;
    8022           0 :         ae_frame_leave(_state);
    8023           0 :         return;
    8024             :     }
    8025           0 :     directdensesolvers_spdbasiccholeskysolve(a, n, isupper, b, _state);
    8026           0 :     ae_frame_leave(_state);
    8027             : }
    8028             : 
    8029             : 
    8030             : /*************************************************************************
    8031             : Dense solver for A*X=B with N*N symmetric positive definite matrix A given
    8032             : by its Cholesky decomposition, and N*M vectors X and B. It  is  "slow-but-
    8033             : feature-rich" version of the solver which estimates  condition  number  of
    8034             : the system.
    8035             : 
    8036             : Algorithm features:
    8037             : * automatic detection of degenerate cases
    8038             : * O(M*N^2) complexity
    8039             : * condition number estimation
    8040             : * matrix is represented by its upper or lower triangle
    8041             : 
    8042             : No iterative refinement is provided because such partial representation of
    8043             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    8044             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    8045             : need iterative refinement.
    8046             : 
    8047             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    8048             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    8049             :            ! which  results  in  significant  performance   penalty   when
    8050             :            ! compared with "fast"  version  which  just  calls  triangular
    8051             :            ! solver. Amount of  overhead  introduced  depends  on  M  (the
    8052             :            ! larger - the more efficient).
    8053             :            !
    8054             :            ! This performance penalty is insignificant  when compared with
    8055             :            ! cost of large LU decomposition.  However,  if you  call  this
    8056             :            ! function many times for the same  left  side,  this  overhead
    8057             :            ! BECOMES significant. It  also  becomes significant for small-
    8058             :            ! scale problems (N<50).
    8059             :            !
    8060             :            ! In such cases we strongly recommend you to use faster solver,
    8061             :            ! SPDMatrixCholeskySolveMFast() function.
    8062             : 
    8063             : INPUT PARAMETERS
    8064             :     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,
    8065             :                 SPDMatrixCholesky result
    8066             :     N       -   size of CHA
    8067             :     IsUpper -   what half of CHA is provided
    8068             :     B       -   array[0..N-1,0..M-1], right part
    8069             :     M       -   right part size
    8070             : 
    8071             : OUTPUT PARAMETERS
    8072             :     Info    -   return code:
    8073             :                 * -3    A is is exactly singular or badly conditioned
    8074             :                         X is filled by zeros in such cases.
    8075             :                 * -1    N<=0 was passed
    8076             :                 *  1    task was solved
    8077             :     Rep     -   additional report, following fields are set:
    8078             :                 * rep.r1    condition number in 1-norm
    8079             :                 * rep.rinf  condition number in inf-norm
    8080             :     X       -   array[N]:
    8081             :                 * for info>0 contains solution
    8082             :                 * for info=-3 filled by zeros
    8083             : 
    8084             :   -- ALGLIB --
    8085             :      Copyright 27.01.2010 by Bochkanov Sergey
    8086             : *************************************************************************/
    8087           0 : void spdmatrixcholeskysolvem(/* Real    */ ae_matrix* cha,
    8088             :      ae_int_t n,
    8089             :      ae_bool isupper,
    8090             :      /* Real    */ ae_matrix* b,
    8091             :      ae_int_t m,
    8092             :      ae_int_t* info,
    8093             :      densesolverreport* rep,
    8094             :      /* Real    */ ae_matrix* x,
    8095             :      ae_state *_state)
    8096             : {
    8097             :     ae_frame _frame_block;
    8098             :     ae_matrix emptya;
    8099             : 
    8100           0 :     ae_frame_make(_state, &_frame_block);
    8101           0 :     memset(&emptya, 0, sizeof(emptya));
    8102           0 :     *info = 0;
    8103           0 :     _densesolverreport_clear(rep);
    8104           0 :     ae_matrix_clear(x);
    8105           0 :     ae_matrix_init(&emptya, 0, 0, DT_REAL, _state, ae_true);
    8106             : 
    8107             :     
    8108             :     /*
    8109             :      * prepare: check inputs, allocate space...
    8110             :      */
    8111           0 :     if( n<=0||m<=0 )
    8112             :     {
    8113           0 :         *info = -1;
    8114           0 :         ae_frame_leave(_state);
    8115           0 :         return;
    8116             :     }
    8117             :     
    8118             :     /*
    8119             :      * solve
    8120             :      */
    8121           0 :     directdensesolvers_spdmatrixcholeskysolveinternal(cha, n, isupper, &emptya, ae_false, b, m, info, rep, x, _state);
    8122           0 :     ae_frame_leave(_state);
    8123             : }
    8124             : 
    8125             : 
    8126             : /*************************************************************************
    8127             : Dense solver for A*X=B with N*N symmetric positive definite matrix A given
    8128             : by its Cholesky decomposition, and N*M vectors X and B. It  is  "fast-but-
    8129             : lightweight" version of  the  solver  which  just  solves  linear  system,
    8130             : without any additional functions.
    8131             : 
    8132             : Algorithm features:
    8133             : * O(M*N^2) complexity
    8134             : * matrix is represented by its upper or lower triangle
    8135             : * no additional functionality
    8136             : 
    8137             : INPUT PARAMETERS
    8138             :     CHA     -   array[N,N], Cholesky decomposition,
    8139             :                 SPDMatrixCholesky result
    8140             :     N       -   size of CHA
    8141             :     IsUpper -   what half of CHA is provided
    8142             :     B       -   array[N,M], right part
    8143             :     M       -   right part size
    8144             : 
    8145             : OUTPUT PARAMETERS
    8146             :     Info    -   return code:
    8147             :                 * -3    A is is exactly singular or badly conditioned
    8148             :                         X is filled by zeros in such cases.
    8149             :                 * -1    N<=0 was passed
    8150             :                 *  1    task was solved
    8151             :     B       -   array[N]:
    8152             :                 * for info>0 overwritten by solution
    8153             :                 * for info=-3 filled by zeros
    8154             : 
    8155             :   -- ALGLIB --
    8156             :      Copyright 18.03.2015 by Bochkanov Sergey
    8157             : *************************************************************************/
    8158           0 : void spdmatrixcholeskysolvemfast(/* Real    */ ae_matrix* cha,
    8159             :      ae_int_t n,
    8160             :      ae_bool isupper,
    8161             :      /* Real    */ ae_matrix* b,
    8162             :      ae_int_t m,
    8163             :      ae_int_t* info,
    8164             :      ae_state *_state)
    8165             : {
    8166             :     ae_int_t i;
    8167             :     ae_int_t j;
    8168             :     ae_int_t k;
    8169             : 
    8170           0 :     *info = 0;
    8171             : 
    8172           0 :     *info = 1;
    8173           0 :     if( n<=0 )
    8174             :     {
    8175           0 :         *info = -1;
    8176           0 :         return;
    8177             :     }
    8178           0 :     for(k=0; k<=n-1; k++)
    8179             :     {
    8180           0 :         if( ae_fp_eq(cha->ptr.pp_double[k][k],0.0) )
    8181             :         {
    8182           0 :             for(i=0; i<=n-1; i++)
    8183             :             {
    8184           0 :                 for(j=0; j<=m-1; j++)
    8185             :                 {
    8186           0 :                     b->ptr.pp_double[i][j] = 0.0;
    8187             :                 }
    8188             :             }
    8189           0 :             *info = -3;
    8190           0 :             return;
    8191             :         }
    8192             :     }
    8193           0 :     if( isupper )
    8194             :     {
    8195           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 1, b, 0, 0, _state);
    8196           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    8197             :     }
    8198             :     else
    8199             :     {
    8200           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 0, b, 0, 0, _state);
    8201           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 1, b, 0, 0, _state);
    8202             :     }
    8203             : }
    8204             : 
    8205             : 
    8206             : /*************************************************************************
    8207             : Dense solver for A*x=b with N*N symmetric positive definite matrix A given
    8208             : by its Cholesky decomposition, and N*1 real vectors x and b. This is "slow-
    8209             : but-feature-rich"  version  of  the  solver  which,  in  addition  to  the
    8210             : solution, performs condition number estimation.
    8211             : 
    8212             : Algorithm features:
    8213             : * automatic detection of degenerate cases
    8214             : * O(N^2) complexity
    8215             : * condition number estimation
    8216             : * matrix is represented by its upper or lower triangle
    8217             : 
    8218             : No iterative refinement is provided because such partial representation of
    8219             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    8220             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    8221             : need iterative refinement.
    8222             : 
    8223             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    8224             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    8225             :            ! which results in 10-15x  performance  penalty  when  compared
    8226             :            ! with "fast" version which just calls triangular solver.
    8227             :            !
    8228             :            ! This performance penalty is insignificant  when compared with
    8229             :            ! cost of large LU decomposition.  However,  if you  call  this
    8230             :            ! function many times for the same  left  side,  this  overhead
    8231             :            ! BECOMES significant. It  also  becomes significant for small-
    8232             :            ! scale problems (N<50).
    8233             :            !
    8234             :            ! In such cases we strongly recommend you to use faster solver,
    8235             :            ! SPDMatrixCholeskySolveFast() function.
    8236             : 
    8237             : INPUT PARAMETERS
    8238             :     CHA     -   array[N,N], Cholesky decomposition,
    8239             :                 SPDMatrixCholesky result
    8240             :     N       -   size of A
    8241             :     IsUpper -   what half of CHA is provided
    8242             :     B       -   array[N], right part
    8243             : 
    8244             : OUTPUT PARAMETERS
    8245             :     Info    -   return code:
    8246             :                 * -3    A is is exactly singular or ill conditioned
    8247             :                         X is filled by zeros in such cases.
    8248             :                 * -1    N<=0 was passed
    8249             :                 *  1    task is solved
    8250             :     Rep     -   additional report, following fields are set:
    8251             :                 * rep.r1    condition number in 1-norm
    8252             :                 * rep.rinf  condition number in inf-norm
    8253             :     X       -   array[N]:
    8254             :                 * for info>0  - solution
    8255             :                 * for info=-3 - filled by zeros
    8256             : 
    8257             :   -- ALGLIB --
    8258             :      Copyright 27.01.2010 by Bochkanov Sergey
    8259             : *************************************************************************/
    8260           0 : void spdmatrixcholeskysolve(/* Real    */ ae_matrix* cha,
    8261             :      ae_int_t n,
    8262             :      ae_bool isupper,
    8263             :      /* Real    */ ae_vector* b,
    8264             :      ae_int_t* info,
    8265             :      densesolverreport* rep,
    8266             :      /* Real    */ ae_vector* x,
    8267             :      ae_state *_state)
    8268             : {
    8269             :     ae_frame _frame_block;
    8270             :     ae_matrix bm;
    8271             :     ae_matrix xm;
    8272             : 
    8273           0 :     ae_frame_make(_state, &_frame_block);
    8274           0 :     memset(&bm, 0, sizeof(bm));
    8275           0 :     memset(&xm, 0, sizeof(xm));
    8276           0 :     *info = 0;
    8277           0 :     _densesolverreport_clear(rep);
    8278           0 :     ae_vector_clear(x);
    8279           0 :     ae_matrix_init(&bm, 0, 0, DT_REAL, _state, ae_true);
    8280           0 :     ae_matrix_init(&xm, 0, 0, DT_REAL, _state, ae_true);
    8281             : 
    8282           0 :     if( n<=0 )
    8283             :     {
    8284           0 :         *info = -1;
    8285           0 :         ae_frame_leave(_state);
    8286           0 :         return;
    8287             :     }
    8288           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    8289           0 :     ae_v_move(&bm.ptr.pp_double[0][0], bm.stride, &b->ptr.p_double[0], 1, ae_v_len(0,n-1));
    8290           0 :     spdmatrixcholeskysolvem(cha, n, isupper, &bm, 1, info, rep, &xm, _state);
    8291           0 :     ae_vector_set_length(x, n, _state);
    8292           0 :     ae_v_move(&x->ptr.p_double[0], 1, &xm.ptr.pp_double[0][0], xm.stride, ae_v_len(0,n-1));
    8293           0 :     ae_frame_leave(_state);
    8294             : }
    8295             : 
    8296             : 
    8297             : /*************************************************************************
    8298             : Dense solver for A*x=b with N*N symmetric positive definite matrix A given
    8299             : by its Cholesky decomposition, and N*1 real vectors x and b. This is "fast-
    8300             : but-lightweight" version of the solver.
    8301             : 
    8302             : Algorithm features:
    8303             : * O(N^2) complexity
    8304             : * matrix is represented by its upper or lower triangle
    8305             : * no additional features
    8306             : 
    8307             : INPUT PARAMETERS
    8308             :     CHA     -   array[N,N], Cholesky decomposition,
    8309             :                 SPDMatrixCholesky result
    8310             :     N       -   size of A
    8311             :     IsUpper -   what half of CHA is provided
    8312             :     B       -   array[N], right part
    8313             : 
    8314             : OUTPUT PARAMETERS
    8315             :     Info    -   return code:
    8316             :                 * -3    A is is exactly singular or ill conditioned
    8317             :                         X is filled by zeros in such cases.
    8318             :                 * -1    N<=0 was passed
    8319             :                 *  1    task is solved
    8320             :     B       -   array[N]:
    8321             :                 * for info>0  - overwritten by solution
    8322             :                 * for info=-3 - filled by zeros
    8323             : 
    8324             :   -- ALGLIB --
    8325             :      Copyright 27.01.2010 by Bochkanov Sergey
    8326             : *************************************************************************/
    8327           0 : void spdmatrixcholeskysolvefast(/* Real    */ ae_matrix* cha,
    8328             :      ae_int_t n,
    8329             :      ae_bool isupper,
    8330             :      /* Real    */ ae_vector* b,
    8331             :      ae_int_t* info,
    8332             :      ae_state *_state)
    8333             : {
    8334             :     ae_int_t i;
    8335             :     ae_int_t k;
    8336             : 
    8337           0 :     *info = 0;
    8338             : 
    8339           0 :     *info = 1;
    8340           0 :     if( n<=0 )
    8341             :     {
    8342           0 :         *info = -1;
    8343           0 :         return;
    8344             :     }
    8345           0 :     for(k=0; k<=n-1; k++)
    8346             :     {
    8347           0 :         if( ae_fp_eq(cha->ptr.pp_double[k][k],0.0) )
    8348             :         {
    8349           0 :             for(i=0; i<=n-1; i++)
    8350             :             {
    8351           0 :                 b->ptr.p_double[i] = 0.0;
    8352             :             }
    8353           0 :             *info = -3;
    8354           0 :             return;
    8355             :         }
    8356             :     }
    8357           0 :     directdensesolvers_spdbasiccholeskysolve(cha, n, isupper, b, _state);
    8358             : }
    8359             : 
    8360             : 
    8361             : /*************************************************************************
    8362             : Dense solver for A*X=B, with N*N Hermitian positive definite matrix A  and
    8363             : N*M  complex  matrices  X  and  B.  "Slow-but-feature-rich" version of the
    8364             : solver.
    8365             : 
    8366             : Algorithm features:
    8367             : * automatic detection of degenerate cases
    8368             : * condition number estimation
    8369             : * O(N^3+M*N^2) complexity
    8370             : * matrix is represented by its upper or lower triangle
    8371             : 
    8372             : No iterative refinement is provided because such partial representation of
    8373             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    8374             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    8375             : need iterative refinement.
    8376             : 
    8377             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    8378             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    8379             :            ! which  results  in  significant  performance   penalty   when
    8380             :            ! compared with "fast"  version  which  just  calls  triangular
    8381             :            ! solver.
    8382             :            !
    8383             :            ! This performance penalty is especially apparent when you  use
    8384             :            ! ALGLIB parallel capabilities (condition number estimation  is
    8385             :            ! inherently  sequential).  It   also   becomes significant for
    8386             :            ! small-scale problems (N<100).
    8387             :            !
    8388             :            ! In such cases we strongly recommend you to use faster solver,
    8389             :            ! HPDMatrixSolveMFast() function.
    8390             : 
    8391             :   ! COMMERCIAL EDITION OF ALGLIB:
    8392             :   ! 
    8393             :   ! Commercial Edition of ALGLIB includes following important improvements
    8394             :   ! of this function:
    8395             :   ! * high-performance native backend with same C# interface (C# version)
    8396             :   ! * multithreading support (C++ and C# versions)
    8397             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    8398             :   !   (C++ and C# versions, x86/x64 platform)
    8399             :   ! 
    8400             :   ! We recommend you to read 'Working with commercial version' section  of
    8401             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    8402             :   ! related features provided by commercial edition of ALGLIB.
    8403             : 
    8404             : INPUT PARAMETERS
    8405             :     A       -   array[0..N-1,0..N-1], system matrix
    8406             :     N       -   size of A
    8407             :     IsUpper -   what half of A is provided
    8408             :     B       -   array[0..N-1,0..M-1], right part
    8409             :     M       -   right part size
    8410             : 
    8411             : OUTPUT PARAMETERS
    8412             :     Info    -   same as in RMatrixSolve.
    8413             :                 Returns -3 for non-HPD matrices.
    8414             :     Rep     -   same as in RMatrixSolve
    8415             :     X       -   same as in RMatrixSolve
    8416             : 
    8417             :   -- ALGLIB --
    8418             :      Copyright 27.01.2010 by Bochkanov Sergey
    8419             : *************************************************************************/
    8420           0 : void hpdmatrixsolvem(/* Complex */ ae_matrix* a,
    8421             :      ae_int_t n,
    8422             :      ae_bool isupper,
    8423             :      /* Complex */ ae_matrix* b,
    8424             :      ae_int_t m,
    8425             :      ae_int_t* info,
    8426             :      densesolverreport* rep,
    8427             :      /* Complex */ ae_matrix* x,
    8428             :      ae_state *_state)
    8429             : {
    8430             :     ae_frame _frame_block;
    8431             :     ae_matrix da;
    8432             :     ae_int_t i;
    8433             :     ae_int_t j;
    8434             :     ae_int_t j1;
    8435             :     ae_int_t j2;
    8436             : 
    8437           0 :     ae_frame_make(_state, &_frame_block);
    8438           0 :     memset(&da, 0, sizeof(da));
    8439           0 :     *info = 0;
    8440           0 :     _densesolverreport_clear(rep);
    8441           0 :     ae_matrix_clear(x);
    8442           0 :     ae_matrix_init(&da, 0, 0, DT_COMPLEX, _state, ae_true);
    8443             : 
    8444             :     
    8445             :     /*
    8446             :      * prepare: check inputs, allocate space...
    8447             :      */
    8448           0 :     if( n<=0||m<=0 )
    8449             :     {
    8450           0 :         *info = -1;
    8451           0 :         ae_frame_leave(_state);
    8452           0 :         return;
    8453             :     }
    8454           0 :     ae_matrix_set_length(&da, n, n, _state);
    8455             :     
    8456             :     /*
    8457             :      * factorize matrix, solve
    8458             :      */
    8459           0 :     for(i=0; i<=n-1; i++)
    8460             :     {
    8461           0 :         if( isupper )
    8462             :         {
    8463           0 :             j1 = i;
    8464           0 :             j2 = n-1;
    8465             :         }
    8466             :         else
    8467             :         {
    8468           0 :             j1 = 0;
    8469           0 :             j2 = i;
    8470             :         }
    8471           0 :         ae_v_cmove(&da.ptr.pp_complex[i][j1], 1, &a->ptr.pp_complex[i][j1], 1, "N", ae_v_len(j1,j2));
    8472             :     }
    8473           0 :     if( !hpdmatrixcholesky(&da, n, isupper, _state) )
    8474             :     {
    8475           0 :         ae_matrix_set_length(x, n, m, _state);
    8476           0 :         for(i=0; i<=n-1; i++)
    8477             :         {
    8478           0 :             for(j=0; j<=m-1; j++)
    8479             :             {
    8480           0 :                 x->ptr.pp_complex[i][j] = ae_complex_from_i(0);
    8481             :             }
    8482             :         }
    8483           0 :         rep->r1 = (double)(0);
    8484           0 :         rep->rinf = (double)(0);
    8485           0 :         *info = -3;
    8486           0 :         ae_frame_leave(_state);
    8487           0 :         return;
    8488             :     }
    8489           0 :     *info = 1;
    8490           0 :     directdensesolvers_hpdmatrixcholeskysolveinternal(&da, n, isupper, a, ae_true, b, m, info, rep, x, _state);
    8491           0 :     ae_frame_leave(_state);
    8492             : }
    8493             : 
    8494             : 
    8495             : /*************************************************************************
    8496             : Dense solver for A*X=B, with N*N Hermitian positive definite matrix A  and
    8497             : N*M complex matrices X and B. "Fast-but-lightweight" version of the solver.
    8498             : 
    8499             : Algorithm features:
    8500             : * O(N^3+M*N^2) complexity
    8501             : * matrix is represented by its upper or lower triangle
    8502             : * no additional time consuming features like condition number estimation
    8503             : 
    8504             :   ! COMMERCIAL EDITION OF ALGLIB:
    8505             :   ! 
    8506             :   ! Commercial Edition of ALGLIB includes following important improvements
    8507             :   ! of this function:
    8508             :   ! * high-performance native backend with same C# interface (C# version)
    8509             :   ! * multithreading support (C++ and C# versions)
    8510             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    8511             :   !   (C++ and C# versions, x86/x64 platform)
    8512             :   ! 
    8513             :   ! We recommend you to read 'Working with commercial version' section  of
    8514             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    8515             :   ! related features provided by commercial edition of ALGLIB.
    8516             : 
    8517             : INPUT PARAMETERS
    8518             :     A       -   array[0..N-1,0..N-1], system matrix
    8519             :     N       -   size of A
    8520             :     IsUpper -   what half of A is provided
    8521             :     B       -   array[0..N-1,0..M-1], right part
    8522             :     M       -   right part size
    8523             : 
    8524             : OUTPUT PARAMETERS
    8525             :     Info    -   return code:
    8526             :                 * -3    A is is exactly  singular or is not positive definite.
    8527             :                         B is filled by zeros in such cases.
    8528             :                 * -1    N<=0 was passed
    8529             :                 *  1    task is solved
    8530             :     B       -   array[0..N-1]:
    8531             :                 * overwritten by solution
    8532             :                 * zeros, if problem was not solved
    8533             : 
    8534             :   -- ALGLIB --
    8535             :      Copyright 17.03.2015 by Bochkanov Sergey
    8536             : *************************************************************************/
    8537           0 : void hpdmatrixsolvemfast(/* Complex */ ae_matrix* a,
    8538             :      ae_int_t n,
    8539             :      ae_bool isupper,
    8540             :      /* Complex */ ae_matrix* b,
    8541             :      ae_int_t m,
    8542             :      ae_int_t* info,
    8543             :      ae_state *_state)
    8544             : {
    8545             :     ae_frame _frame_block;
    8546             :     ae_matrix _a;
    8547             :     ae_int_t i;
    8548             :     ae_int_t j;
    8549             : 
    8550           0 :     ae_frame_make(_state, &_frame_block);
    8551           0 :     memset(&_a, 0, sizeof(_a));
    8552           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    8553           0 :     a = &_a;
    8554           0 :     *info = 0;
    8555             : 
    8556           0 :     *info = 1;
    8557           0 :     if( n<=0 )
    8558             :     {
    8559           0 :         *info = -1;
    8560           0 :         ae_frame_leave(_state);
    8561           0 :         return;
    8562             :     }
    8563           0 :     if( !hpdmatrixcholesky(a, n, isupper, _state) )
    8564             :     {
    8565           0 :         for(i=0; i<=n-1; i++)
    8566             :         {
    8567           0 :             for(j=0; j<=m-1; j++)
    8568             :             {
    8569           0 :                 b->ptr.pp_complex[i][j] = ae_complex_from_d(0.0);
    8570             :             }
    8571             :         }
    8572           0 :         *info = -3;
    8573           0 :         ae_frame_leave(_state);
    8574           0 :         return;
    8575             :     }
    8576           0 :     if( isupper )
    8577             :     {
    8578           0 :         cmatrixlefttrsm(n, m, a, 0, 0, ae_true, ae_false, 2, b, 0, 0, _state);
    8579           0 :         cmatrixlefttrsm(n, m, a, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    8580             :     }
    8581             :     else
    8582             :     {
    8583           0 :         cmatrixlefttrsm(n, m, a, 0, 0, ae_false, ae_false, 0, b, 0, 0, _state);
    8584           0 :         cmatrixlefttrsm(n, m, a, 0, 0, ae_false, ae_false, 2, b, 0, 0, _state);
    8585             :     }
    8586           0 :     ae_frame_leave(_state);
    8587             : }
    8588             : 
    8589             : 
    8590             : /*************************************************************************
    8591             : Dense solver for A*x=b, with N*N Hermitian positive definite matrix A, and
    8592             : N*1 complex vectors  x  and  b.  "Slow-but-feature-rich"  version  of  the
    8593             : solver.
    8594             : 
    8595             : Algorithm features:
    8596             : * automatic detection of degenerate cases
    8597             : * condition number estimation
    8598             : * O(N^3) complexity
    8599             : * matrix is represented by its upper or lower triangle
    8600             : 
    8601             : No iterative refinement is provided because such partial representation of
    8602             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    8603             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    8604             : need iterative refinement.
    8605             : 
    8606             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    8607             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    8608             :            ! which  results  in  significant   performance   penalty  when
    8609             :            ! compared with "fast" version  which  just  performs  Cholesky
    8610             :            ! decomposition and calls triangular solver.
    8611             :            !
    8612             :            ! This  performance  penalty  is  especially  visible  in   the
    8613             :            ! multithreaded mode, because both condition number  estimation
    8614             :            ! and   iterative    refinement   are   inherently   sequential
    8615             :            ! calculations.
    8616             :            !
    8617             :            ! Thus, if you need high performance and if you are pretty sure
    8618             :            ! that your system is well conditioned, we  strongly  recommend
    8619             :            ! you to use faster solver, HPDMatrixSolveFast() function.
    8620             : 
    8621             :   ! COMMERCIAL EDITION OF ALGLIB:
    8622             :   ! 
    8623             :   ! Commercial Edition of ALGLIB includes following important improvements
    8624             :   ! of this function:
    8625             :   ! * high-performance native backend with same C# interface (C# version)
    8626             :   ! * multithreading support (C++ and C# versions)
    8627             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    8628             :   !   (C++ and C# versions, x86/x64 platform)
    8629             :   ! 
    8630             :   ! We recommend you to read 'Working with commercial version' section  of
    8631             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    8632             :   ! related features provided by commercial edition of ALGLIB.
    8633             : 
    8634             : INPUT PARAMETERS
    8635             :     A       -   array[0..N-1,0..N-1], system matrix
    8636             :     N       -   size of A
    8637             :     IsUpper -   what half of A is provided
    8638             :     B       -   array[0..N-1], right part
    8639             : 
    8640             : OUTPUT PARAMETERS
    8641             :     Info    -   same as in RMatrixSolve
    8642             :                 Returns -3 for non-HPD matrices.
    8643             :     Rep     -   same as in RMatrixSolve
    8644             :     X       -   same as in RMatrixSolve
    8645             : 
    8646             :   -- ALGLIB --
    8647             :      Copyright 27.01.2010 by Bochkanov Sergey
    8648             : *************************************************************************/
    8649           0 : void hpdmatrixsolve(/* Complex */ ae_matrix* a,
    8650             :      ae_int_t n,
    8651             :      ae_bool isupper,
    8652             :      /* Complex */ ae_vector* b,
    8653             :      ae_int_t* info,
    8654             :      densesolverreport* rep,
    8655             :      /* Complex */ ae_vector* x,
    8656             :      ae_state *_state)
    8657             : {
    8658             :     ae_frame _frame_block;
    8659             :     ae_matrix bm;
    8660             :     ae_matrix xm;
    8661             : 
    8662           0 :     ae_frame_make(_state, &_frame_block);
    8663           0 :     memset(&bm, 0, sizeof(bm));
    8664           0 :     memset(&xm, 0, sizeof(xm));
    8665           0 :     *info = 0;
    8666           0 :     _densesolverreport_clear(rep);
    8667           0 :     ae_vector_clear(x);
    8668           0 :     ae_matrix_init(&bm, 0, 0, DT_COMPLEX, _state, ae_true);
    8669           0 :     ae_matrix_init(&xm, 0, 0, DT_COMPLEX, _state, ae_true);
    8670             : 
    8671           0 :     if( n<=0 )
    8672             :     {
    8673           0 :         *info = -1;
    8674           0 :         ae_frame_leave(_state);
    8675           0 :         return;
    8676             :     }
    8677           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    8678           0 :     ae_v_cmove(&bm.ptr.pp_complex[0][0], bm.stride, &b->ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    8679           0 :     hpdmatrixsolvem(a, n, isupper, &bm, 1, info, rep, &xm, _state);
    8680           0 :     ae_vector_set_length(x, n, _state);
    8681           0 :     ae_v_cmove(&x->ptr.p_complex[0], 1, &xm.ptr.pp_complex[0][0], xm.stride, "N", ae_v_len(0,n-1));
    8682           0 :     ae_frame_leave(_state);
    8683             : }
    8684             : 
    8685             : 
    8686             : /*************************************************************************
    8687             : Dense solver for A*x=b, with N*N Hermitian positive definite matrix A, and
    8688             : N*1 complex vectors  x  and  b.  "Fast-but-lightweight"  version  of   the
    8689             : solver without additional functions.
    8690             : 
    8691             : Algorithm features:
    8692             : * O(N^3) complexity
    8693             : * matrix is represented by its upper or lower triangle
    8694             : * no additional time consuming functions
    8695             : 
    8696             :   ! COMMERCIAL EDITION OF ALGLIB:
    8697             :   ! 
    8698             :   ! Commercial Edition of ALGLIB includes following important improvements
    8699             :   ! of this function:
    8700             :   ! * high-performance native backend with same C# interface (C# version)
    8701             :   ! * multithreading support (C++ and C# versions)
    8702             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    8703             :   !   (C++ and C# versions, x86/x64 platform)
    8704             :   ! 
    8705             :   ! We recommend you to read 'Working with commercial version' section  of
    8706             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    8707             :   ! related features provided by commercial edition of ALGLIB.
    8708             : 
    8709             : INPUT PARAMETERS
    8710             :     A       -   array[0..N-1,0..N-1], system matrix
    8711             :     N       -   size of A
    8712             :     IsUpper -   what half of A is provided
    8713             :     B       -   array[0..N-1], right part
    8714             : 
    8715             : OUTPUT PARAMETERS
    8716             :     Info    -   return code:
    8717             :                 * -3    A is is exactly singular or not positive definite
    8718             :                         X is filled by zeros in such cases.
    8719             :                 * -1    N<=0 was passed
    8720             :                 *  1    task was solved 
    8721             :     B       -   array[0..N-1]:
    8722             :                 * overwritten by solution
    8723             :                 * zeros, if A is exactly singular (diagonal of its LU
    8724             :                   decomposition has exact zeros).
    8725             : 
    8726             :   -- ALGLIB --
    8727             :      Copyright 17.03.2015 by Bochkanov Sergey
    8728             : *************************************************************************/
    8729           0 : void hpdmatrixsolvefast(/* Complex */ ae_matrix* a,
    8730             :      ae_int_t n,
    8731             :      ae_bool isupper,
    8732             :      /* Complex */ ae_vector* b,
    8733             :      ae_int_t* info,
    8734             :      ae_state *_state)
    8735             : {
    8736             :     ae_frame _frame_block;
    8737             :     ae_matrix _a;
    8738             :     ae_int_t i;
    8739             : 
    8740           0 :     ae_frame_make(_state, &_frame_block);
    8741           0 :     memset(&_a, 0, sizeof(_a));
    8742           0 :     ae_matrix_init_copy(&_a, a, _state, ae_true);
    8743           0 :     a = &_a;
    8744           0 :     *info = 0;
    8745             : 
    8746           0 :     *info = 1;
    8747           0 :     if( n<=0 )
    8748             :     {
    8749           0 :         *info = -1;
    8750           0 :         ae_frame_leave(_state);
    8751           0 :         return;
    8752             :     }
    8753           0 :     if( !hpdmatrixcholesky(a, n, isupper, _state) )
    8754             :     {
    8755           0 :         for(i=0; i<=n-1; i++)
    8756             :         {
    8757           0 :             b->ptr.p_complex[i] = ae_complex_from_d(0.0);
    8758             :         }
    8759           0 :         *info = -3;
    8760           0 :         ae_frame_leave(_state);
    8761           0 :         return;
    8762             :     }
    8763           0 :     directdensesolvers_hpdbasiccholeskysolve(a, n, isupper, b, _state);
    8764           0 :     ae_frame_leave(_state);
    8765             : }
    8766             : 
    8767             : 
    8768             : /*************************************************************************
    8769             : Dense solver for A*X=B with N*N Hermitian positive definite matrix A given
    8770             : by its Cholesky decomposition and N*M complex matrices X  and  B.  This is
    8771             : "slow-but-feature-rich" version of the solver which, in  addition  to  the
    8772             : solution, estimates condition number of the system.
    8773             : 
    8774             : Algorithm features:
    8775             : * automatic detection of degenerate cases
    8776             : * O(M*N^2) complexity
    8777             : * condition number estimation
    8778             : * matrix is represented by its upper or lower triangle
    8779             : 
    8780             : No iterative refinement is provided because such partial representation of
    8781             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    8782             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    8783             : need iterative refinement.
    8784             : 
    8785             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    8786             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    8787             :            ! which  results  in  significant  performance   penalty   when
    8788             :            ! compared with "fast"  version  which  just  calls  triangular
    8789             :            ! solver. Amount of  overhead  introduced  depends  on  M  (the
    8790             :            ! larger - the more efficient).
    8791             :            !
    8792             :            ! This performance penalty is insignificant  when compared with
    8793             :            ! cost of large Cholesky decomposition.  However,  if  you call
    8794             :            ! this  function  many  times  for  the same  left  side,  this
    8795             :            ! overhead BECOMES significant. It  also   becomes  significant
    8796             :            ! for small-scale problems (N<50).
    8797             :            !
    8798             :            ! In such cases we strongly recommend you to use faster solver,
    8799             :            ! HPDMatrixCholeskySolveMFast() function.
    8800             : 
    8801             : 
    8802             : INPUT PARAMETERS
    8803             :     CHA     -   array[N,N], Cholesky decomposition,
    8804             :                 HPDMatrixCholesky result
    8805             :     N       -   size of CHA
    8806             :     IsUpper -   what half of CHA is provided
    8807             :     B       -   array[N,M], right part
    8808             :     M       -   right part size
    8809             : 
    8810             : OUTPUT PARAMETERS:
    8811             :     Info    -   return code:
    8812             :                 * -3    A is singular, or VERY close to singular.
    8813             :                         X is filled by zeros in such cases.
    8814             :                 * -1    N<=0 was passed
    8815             :                 *  1    task was solved
    8816             :     Rep     -   additional report, following fields are set:
    8817             :                 * rep.r1    condition number in 1-norm
    8818             :                 * rep.rinf  condition number in inf-norm
    8819             :     X       -   array[N]:
    8820             :                 * for info>0 contains solution
    8821             :                 * for info=-3 filled by zeros
    8822             : 
    8823             :   -- ALGLIB --
    8824             :      Copyright 27.01.2010 by Bochkanov Sergey
    8825             : *************************************************************************/
    8826           0 : void hpdmatrixcholeskysolvem(/* Complex */ ae_matrix* cha,
    8827             :      ae_int_t n,
    8828             :      ae_bool isupper,
    8829             :      /* Complex */ ae_matrix* b,
    8830             :      ae_int_t m,
    8831             :      ae_int_t* info,
    8832             :      densesolverreport* rep,
    8833             :      /* Complex */ ae_matrix* x,
    8834             :      ae_state *_state)
    8835             : {
    8836             :     ae_frame _frame_block;
    8837             :     ae_matrix emptya;
    8838             : 
    8839           0 :     ae_frame_make(_state, &_frame_block);
    8840           0 :     memset(&emptya, 0, sizeof(emptya));
    8841           0 :     *info = 0;
    8842           0 :     _densesolverreport_clear(rep);
    8843           0 :     ae_matrix_clear(x);
    8844           0 :     ae_matrix_init(&emptya, 0, 0, DT_COMPLEX, _state, ae_true);
    8845             : 
    8846             :     
    8847             :     /*
    8848             :      * prepare: check inputs, allocate space...
    8849             :      */
    8850           0 :     if( n<=0||m<=0 )
    8851             :     {
    8852           0 :         *info = -1;
    8853           0 :         ae_frame_leave(_state);
    8854           0 :         return;
    8855             :     }
    8856             :     
    8857             :     /*
    8858             :      * 1. scale matrix, max(|U[i,j]|)
    8859             :      * 2. factorize scaled matrix
    8860             :      * 3. solve
    8861             :      */
    8862           0 :     directdensesolvers_hpdmatrixcholeskysolveinternal(cha, n, isupper, &emptya, ae_false, b, m, info, rep, x, _state);
    8863           0 :     ae_frame_leave(_state);
    8864             : }
    8865             : 
    8866             : 
    8867             : /*************************************************************************
    8868             : Dense solver for A*X=B with N*N Hermitian positive definite matrix A given
    8869             : by its Cholesky decomposition and N*M complex matrices X  and  B.  This is
    8870             : "fast-but-lightweight" version of the solver.
    8871             : 
    8872             : Algorithm features:
    8873             : * O(M*N^2) complexity
    8874             : * matrix is represented by its upper or lower triangle
    8875             : * no additional time-consuming features
    8876             : 
    8877             : INPUT PARAMETERS
    8878             :     CHA     -   array[N,N], Cholesky decomposition,
    8879             :                 HPDMatrixCholesky result
    8880             :     N       -   size of CHA
    8881             :     IsUpper -   what half of CHA is provided
    8882             :     B       -   array[N,M], right part
    8883             :     M       -   right part size
    8884             : 
    8885             : OUTPUT PARAMETERS:
    8886             :     Info    -   return code:
    8887             :                 * -3    A is singular, or VERY close to singular.
    8888             :                         X is filled by zeros in such cases.
    8889             :                 * -1    N<=0 was passed
    8890             :                 *  1    task was solved
    8891             :     B       -   array[N]:
    8892             :                 * for info>0 overwritten by solution
    8893             :                 * for info=-3 filled by zeros
    8894             : 
    8895             :   -- ALGLIB --
    8896             :      Copyright 18.03.2015 by Bochkanov Sergey
    8897             : *************************************************************************/
    8898           0 : void hpdmatrixcholeskysolvemfast(/* Complex */ ae_matrix* cha,
    8899             :      ae_int_t n,
    8900             :      ae_bool isupper,
    8901             :      /* Complex */ ae_matrix* b,
    8902             :      ae_int_t m,
    8903             :      ae_int_t* info,
    8904             :      ae_state *_state)
    8905             : {
    8906             :     ae_int_t i;
    8907             :     ae_int_t j;
    8908             :     ae_int_t k;
    8909             : 
    8910           0 :     *info = 0;
    8911             : 
    8912           0 :     *info = 1;
    8913           0 :     if( n<=0 )
    8914             :     {
    8915           0 :         *info = -1;
    8916           0 :         return;
    8917             :     }
    8918           0 :     for(k=0; k<=n-1; k++)
    8919             :     {
    8920           0 :         if( ae_fp_eq(cha->ptr.pp_complex[k][k].x,0.0)&&ae_fp_eq(cha->ptr.pp_complex[k][k].y,0.0) )
    8921             :         {
    8922           0 :             for(i=0; i<=n-1; i++)
    8923             :             {
    8924           0 :                 for(j=0; j<=m-1; j++)
    8925             :                 {
    8926           0 :                     b->ptr.pp_complex[i][j] = ae_complex_from_d(0.0);
    8927             :                 }
    8928             :             }
    8929           0 :             *info = -3;
    8930           0 :             return;
    8931             :         }
    8932             :     }
    8933           0 :     if( isupper )
    8934             :     {
    8935           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 2, b, 0, 0, _state);
    8936           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 0, b, 0, 0, _state);
    8937             :     }
    8938             :     else
    8939             :     {
    8940           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 0, b, 0, 0, _state);
    8941           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 2, b, 0, 0, _state);
    8942             :     }
    8943             : }
    8944             : 
    8945             : 
    8946             : /*************************************************************************
    8947             : Dense solver for A*x=b with N*N Hermitian positive definite matrix A given
    8948             : by its Cholesky decomposition, and N*1 complex vectors x and  b.  This  is
    8949             : "slow-but-feature-rich" version of the solver  which  estimates  condition
    8950             : number of the system.
    8951             : 
    8952             : Algorithm features:
    8953             : * automatic detection of degenerate cases
    8954             : * O(N^2) complexity
    8955             : * condition number estimation
    8956             : * matrix is represented by its upper or lower triangle
    8957             : 
    8958             : No iterative refinement is provided because such partial representation of
    8959             : matrix does not allow efficient calculation of extra-precise  matrix-vector
    8960             : products for large matrices. Use RMatrixSolve or RMatrixMixedSolve  if  you
    8961             : need iterative refinement.
    8962             : 
    8963             : IMPORTANT: ! this function is NOT the most efficient linear solver provided
    8964             :            ! by ALGLIB. It estimates condition  number  of  linear system,
    8965             :            ! which results in 10-15x  performance  penalty  when  compared
    8966             :            ! with "fast" version which just calls triangular solver.
    8967             :            !
    8968             :            ! This performance penalty is insignificant  when compared with
    8969             :            ! cost of large LU decomposition.  However,  if you  call  this
    8970             :            ! function many times for the same  left  side,  this  overhead
    8971             :            ! BECOMES significant. It  also  becomes significant for small-
    8972             :            ! scale problems (N<50).
    8973             :            !
    8974             :            ! In such cases we strongly recommend you to use faster solver,
    8975             :            ! HPDMatrixCholeskySolveFast() function.
    8976             : 
    8977             : INPUT PARAMETERS
    8978             :     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,
    8979             :                 SPDMatrixCholesky result
    8980             :     N       -   size of A
    8981             :     IsUpper -   what half of CHA is provided
    8982             :     B       -   array[0..N-1], right part
    8983             : 
    8984             : OUTPUT PARAMETERS
    8985             :     Info    -   return code:
    8986             :                 * -3    A is is exactly singular or ill conditioned
    8987             :                         X is filled by zeros in such cases.
    8988             :                 * -1    N<=0 was passed
    8989             :                 *  1    task is solved
    8990             :     Rep     -   additional report, following fields are set:
    8991             :                 * rep.r1    condition number in 1-norm
    8992             :                 * rep.rinf  condition number in inf-norm
    8993             :     X       -   array[N]:
    8994             :                 * for info>0  - solution
    8995             :                 * for info=-3 - filled by zeros
    8996             : 
    8997             :   -- ALGLIB --
    8998             :      Copyright 27.01.2010 by Bochkanov Sergey
    8999             : *************************************************************************/
    9000           0 : void hpdmatrixcholeskysolve(/* Complex */ ae_matrix* cha,
    9001             :      ae_int_t n,
    9002             :      ae_bool isupper,
    9003             :      /* Complex */ ae_vector* b,
    9004             :      ae_int_t* info,
    9005             :      densesolverreport* rep,
    9006             :      /* Complex */ ae_vector* x,
    9007             :      ae_state *_state)
    9008             : {
    9009             :     ae_frame _frame_block;
    9010             :     ae_matrix bm;
    9011             :     ae_matrix xm;
    9012             : 
    9013           0 :     ae_frame_make(_state, &_frame_block);
    9014           0 :     memset(&bm, 0, sizeof(bm));
    9015           0 :     memset(&xm, 0, sizeof(xm));
    9016           0 :     *info = 0;
    9017           0 :     _densesolverreport_clear(rep);
    9018           0 :     ae_vector_clear(x);
    9019           0 :     ae_matrix_init(&bm, 0, 0, DT_COMPLEX, _state, ae_true);
    9020           0 :     ae_matrix_init(&xm, 0, 0, DT_COMPLEX, _state, ae_true);
    9021             : 
    9022           0 :     if( n<=0 )
    9023             :     {
    9024           0 :         *info = -1;
    9025           0 :         ae_frame_leave(_state);
    9026           0 :         return;
    9027             :     }
    9028           0 :     ae_matrix_set_length(&bm, n, 1, _state);
    9029           0 :     ae_v_cmove(&bm.ptr.pp_complex[0][0], bm.stride, &b->ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    9030           0 :     hpdmatrixcholeskysolvem(cha, n, isupper, &bm, 1, info, rep, &xm, _state);
    9031           0 :     ae_vector_set_length(x, n, _state);
    9032           0 :     ae_v_cmove(&x->ptr.p_complex[0], 1, &xm.ptr.pp_complex[0][0], xm.stride, "N", ae_v_len(0,n-1));
    9033           0 :     ae_frame_leave(_state);
    9034             : }
    9035             : 
    9036             : 
    9037             : /*************************************************************************
    9038             : Dense solver for A*x=b with N*N Hermitian positive definite matrix A given
    9039             : by its Cholesky decomposition, and N*1 complex vectors x and  b.  This  is
    9040             : "fast-but-lightweight" version of the solver.
    9041             : 
    9042             : Algorithm features:
    9043             : * O(N^2) complexity
    9044             : * matrix is represented by its upper or lower triangle
    9045             : * no additional time-consuming features
    9046             : 
    9047             : INPUT PARAMETERS
    9048             :     CHA     -   array[0..N-1,0..N-1], Cholesky decomposition,
    9049             :                 SPDMatrixCholesky result
    9050             :     N       -   size of A
    9051             :     IsUpper -   what half of CHA is provided
    9052             :     B       -   array[0..N-1], right part
    9053             : 
    9054             : OUTPUT PARAMETERS
    9055             :     Info    -   return code:
    9056             :                 * -3    A is is exactly singular or ill conditioned
    9057             :                         B is filled by zeros in such cases.
    9058             :                 * -1    N<=0 was passed
    9059             :                 *  1    task is solved
    9060             :     B       -   array[N]:
    9061             :                 * for info>0  - overwritten by solution
    9062             :                 * for info=-3 - filled by zeros
    9063             : 
    9064             :   -- ALGLIB --
    9065             :      Copyright 18.03.2015 by Bochkanov Sergey
    9066             : *************************************************************************/
    9067           0 : void hpdmatrixcholeskysolvefast(/* Complex */ ae_matrix* cha,
    9068             :      ae_int_t n,
    9069             :      ae_bool isupper,
    9070             :      /* Complex */ ae_vector* b,
    9071             :      ae_int_t* info,
    9072             :      ae_state *_state)
    9073             : {
    9074             :     ae_int_t i;
    9075             :     ae_int_t k;
    9076             : 
    9077           0 :     *info = 0;
    9078             : 
    9079           0 :     *info = 1;
    9080           0 :     if( n<=0 )
    9081             :     {
    9082           0 :         *info = -1;
    9083           0 :         return;
    9084             :     }
    9085           0 :     for(k=0; k<=n-1; k++)
    9086             :     {
    9087           0 :         if( ae_fp_eq(cha->ptr.pp_complex[k][k].x,0.0)&&ae_fp_eq(cha->ptr.pp_complex[k][k].y,0.0) )
    9088             :         {
    9089           0 :             for(i=0; i<=n-1; i++)
    9090             :             {
    9091           0 :                 b->ptr.p_complex[i] = ae_complex_from_d(0.0);
    9092             :             }
    9093           0 :             *info = -3;
    9094           0 :             return;
    9095             :         }
    9096             :     }
    9097           0 :     directdensesolvers_hpdbasiccholeskysolve(cha, n, isupper, b, _state);
    9098             : }
    9099             : 
    9100             : 
    9101             : /*************************************************************************
    9102             : Dense solver.
    9103             : 
    9104             : This subroutine finds solution of the linear system A*X=B with non-square,
    9105             : possibly degenerate A.  System  is  solved in the least squares sense, and
    9106             : general least squares solution  X = X0 + CX*y  which  minimizes |A*X-B| is
    9107             : returned. If A is non-degenerate, solution in the usual sense is returned.
    9108             : 
    9109             : Algorithm features:
    9110             : * automatic detection (and correct handling!) of degenerate cases
    9111             : * iterative refinement
    9112             : * O(N^3) complexity
    9113             : 
    9114             :   ! COMMERCIAL EDITION OF ALGLIB:
    9115             :   ! 
    9116             :   ! Commercial Edition of ALGLIB includes following important improvements
    9117             :   ! of this function:
    9118             :   ! * high-performance native backend with same C# interface (C# version)
    9119             :   ! * multithreading support (C++ and C# versions)
    9120             :   ! * hardware vendor (Intel) implementations of linear algebra primitives
    9121             :   !   (C++ and C# versions, x86/x64 platform)
    9122             :   ! 
    9123             :   ! We recommend you to read 'Working with commercial version' section  of
    9124             :   ! ALGLIB Reference Manual in order to find out how to  use  performance-
    9125             :   ! related features provided by commercial edition of ALGLIB.
    9126             : 
    9127             : INPUT PARAMETERS
    9128             :     A       -   array[0..NRows-1,0..NCols-1], system matrix
    9129             :     NRows   -   vertical size of A
    9130             :     NCols   -   horizontal size of A
    9131             :     B       -   array[0..NCols-1], right part
    9132             :     Threshold-  a number in [0,1]. Singular values  beyond  Threshold  are
    9133             :                 considered  zero.  Set  it to 0.0, if you don't understand
    9134             :                 what it means, so the solver will choose good value on its
    9135             :                 own.
    9136             :                 
    9137             : OUTPUT PARAMETERS
    9138             :     Info    -   return code:
    9139             :                 * -4    SVD subroutine failed
    9140             :                 * -1    if NRows<=0 or NCols<=0 or Threshold<0 was passed
    9141             :                 *  1    if task is solved
    9142             :     Rep     -   solver report, see below for more info
    9143             :     X       -   array[0..N-1,0..M-1], it contains:
    9144             :                 * solution of A*X=B (even for singular A)
    9145             :                 * zeros, if SVD subroutine failed
    9146             : 
    9147             : SOLVER REPORT
    9148             : 
    9149             : Subroutine sets following fields of the Rep structure:
    9150             : * R2        reciprocal of condition number: 1/cond(A), 2-norm.
    9151             : * N         = NCols
    9152             : * K         dim(Null(A))
    9153             : * CX        array[0..N-1,0..K-1], kernel of A.
    9154             :             Columns of CX store such vectors that A*CX[i]=0.
    9155             : 
    9156             :   -- ALGLIB --
    9157             :      Copyright 24.08.2009 by Bochkanov Sergey
    9158             : *************************************************************************/
    9159           0 : void rmatrixsolvels(/* Real    */ ae_matrix* a,
    9160             :      ae_int_t nrows,
    9161             :      ae_int_t ncols,
    9162             :      /* Real    */ ae_vector* b,
    9163             :      double threshold,
    9164             :      ae_int_t* info,
    9165             :      densesolverlsreport* rep,
    9166             :      /* Real    */ ae_vector* x,
    9167             :      ae_state *_state)
    9168             : {
    9169             :     ae_frame _frame_block;
    9170             :     ae_vector sv;
    9171             :     ae_matrix u;
    9172             :     ae_matrix vt;
    9173             :     ae_vector rp;
    9174             :     ae_vector utb;
    9175             :     ae_vector sutb;
    9176             :     ae_vector tmp;
    9177             :     ae_vector ta;
    9178             :     ae_vector tx;
    9179             :     ae_vector buf;
    9180             :     ae_vector w;
    9181             :     ae_int_t i;
    9182             :     ae_int_t j;
    9183             :     ae_int_t nsv;
    9184             :     ae_int_t kernelidx;
    9185             :     double v;
    9186             :     double verr;
    9187             :     ae_bool svdfailed;
    9188             :     ae_bool zeroa;
    9189             :     ae_int_t rfs;
    9190             :     ae_int_t nrfs;
    9191             :     ae_bool terminatenexttime;
    9192             :     ae_bool smallerr;
    9193             : 
    9194           0 :     ae_frame_make(_state, &_frame_block);
    9195           0 :     memset(&sv, 0, sizeof(sv));
    9196           0 :     memset(&u, 0, sizeof(u));
    9197           0 :     memset(&vt, 0, sizeof(vt));
    9198           0 :     memset(&rp, 0, sizeof(rp));
    9199           0 :     memset(&utb, 0, sizeof(utb));
    9200           0 :     memset(&sutb, 0, sizeof(sutb));
    9201           0 :     memset(&tmp, 0, sizeof(tmp));
    9202           0 :     memset(&ta, 0, sizeof(ta));
    9203           0 :     memset(&tx, 0, sizeof(tx));
    9204           0 :     memset(&buf, 0, sizeof(buf));
    9205           0 :     memset(&w, 0, sizeof(w));
    9206           0 :     *info = 0;
    9207           0 :     _densesolverlsreport_clear(rep);
    9208           0 :     ae_vector_clear(x);
    9209           0 :     ae_vector_init(&sv, 0, DT_REAL, _state, ae_true);
    9210           0 :     ae_matrix_init(&u, 0, 0, DT_REAL, _state, ae_true);
    9211           0 :     ae_matrix_init(&vt, 0, 0, DT_REAL, _state, ae_true);
    9212           0 :     ae_vector_init(&rp, 0, DT_REAL, _state, ae_true);
    9213           0 :     ae_vector_init(&utb, 0, DT_REAL, _state, ae_true);
    9214           0 :     ae_vector_init(&sutb, 0, DT_REAL, _state, ae_true);
    9215           0 :     ae_vector_init(&tmp, 0, DT_REAL, _state, ae_true);
    9216           0 :     ae_vector_init(&ta, 0, DT_REAL, _state, ae_true);
    9217           0 :     ae_vector_init(&tx, 0, DT_REAL, _state, ae_true);
    9218           0 :     ae_vector_init(&buf, 0, DT_REAL, _state, ae_true);
    9219           0 :     ae_vector_init(&w, 0, DT_REAL, _state, ae_true);
    9220             : 
    9221           0 :     if( (nrows<=0||ncols<=0)||ae_fp_less(threshold,(double)(0)) )
    9222             :     {
    9223           0 :         *info = -1;
    9224           0 :         ae_frame_leave(_state);
    9225           0 :         return;
    9226             :     }
    9227           0 :     if( ae_fp_eq(threshold,(double)(0)) )
    9228             :     {
    9229           0 :         threshold = 1000*ae_machineepsilon;
    9230             :     }
    9231             :     
    9232             :     /*
    9233             :      * Factorize A first
    9234             :      */
    9235           0 :     svdfailed = !rmatrixsvd(a, nrows, ncols, 1, 2, 2, &sv, &u, &vt, _state);
    9236           0 :     zeroa = ae_fp_eq(sv.ptr.p_double[0],(double)(0));
    9237           0 :     if( svdfailed||zeroa )
    9238             :     {
    9239           0 :         if( svdfailed )
    9240             :         {
    9241           0 :             *info = -4;
    9242             :         }
    9243             :         else
    9244             :         {
    9245           0 :             *info = 1;
    9246             :         }
    9247           0 :         ae_vector_set_length(x, ncols, _state);
    9248           0 :         for(i=0; i<=ncols-1; i++)
    9249             :         {
    9250           0 :             x->ptr.p_double[i] = (double)(0);
    9251             :         }
    9252           0 :         rep->n = ncols;
    9253           0 :         rep->k = ncols;
    9254           0 :         ae_matrix_set_length(&rep->cx, ncols, ncols, _state);
    9255           0 :         for(i=0; i<=ncols-1; i++)
    9256             :         {
    9257           0 :             for(j=0; j<=ncols-1; j++)
    9258             :             {
    9259           0 :                 if( i==j )
    9260             :                 {
    9261           0 :                     rep->cx.ptr.pp_double[i][j] = (double)(1);
    9262             :                 }
    9263             :                 else
    9264             :                 {
    9265           0 :                     rep->cx.ptr.pp_double[i][j] = (double)(0);
    9266             :                 }
    9267             :             }
    9268             :         }
    9269           0 :         rep->r2 = (double)(0);
    9270           0 :         ae_frame_leave(_state);
    9271           0 :         return;
    9272             :     }
    9273           0 :     nsv = ae_minint(ncols, nrows, _state);
    9274           0 :     if( nsv==ncols )
    9275             :     {
    9276           0 :         rep->r2 = sv.ptr.p_double[nsv-1]/sv.ptr.p_double[0];
    9277             :     }
    9278             :     else
    9279             :     {
    9280           0 :         rep->r2 = (double)(0);
    9281             :     }
    9282           0 :     rep->n = ncols;
    9283           0 :     *info = 1;
    9284             :     
    9285             :     /*
    9286             :      * Iterative refinement of xc combined with solution:
    9287             :      * 1. xc = 0
    9288             :      * 2. calculate r = bc-A*xc using extra-precise dot product
    9289             :      * 3. solve A*y = r
    9290             :      * 4. update x:=x+r
    9291             :      * 5. goto 2
    9292             :      *
    9293             :      * This cycle is executed until one of two things happens:
    9294             :      * 1. maximum number of iterations reached
    9295             :      * 2. last iteration decreased error to the lower limit
    9296             :      */
    9297           0 :     ae_vector_set_length(&utb, nsv, _state);
    9298           0 :     ae_vector_set_length(&sutb, nsv, _state);
    9299           0 :     ae_vector_set_length(x, ncols, _state);
    9300           0 :     ae_vector_set_length(&tmp, ncols, _state);
    9301           0 :     ae_vector_set_length(&ta, ncols+1, _state);
    9302           0 :     ae_vector_set_length(&tx, ncols+1, _state);
    9303           0 :     ae_vector_set_length(&buf, ncols+1, _state);
    9304           0 :     for(i=0; i<=ncols-1; i++)
    9305             :     {
    9306           0 :         x->ptr.p_double[i] = (double)(0);
    9307             :     }
    9308           0 :     kernelidx = nsv;
    9309           0 :     for(i=0; i<=nsv-1; i++)
    9310             :     {
    9311           0 :         if( ae_fp_less_eq(sv.ptr.p_double[i],threshold*sv.ptr.p_double[0]) )
    9312             :         {
    9313           0 :             kernelidx = i;
    9314           0 :             break;
    9315             :         }
    9316             :     }
    9317           0 :     rep->k = ncols-kernelidx;
    9318           0 :     nrfs = directdensesolvers_densesolverrfsmaxv2(ncols, rep->r2, _state);
    9319           0 :     terminatenexttime = ae_false;
    9320           0 :     ae_vector_set_length(&rp, nrows, _state);
    9321           0 :     for(rfs=0; rfs<=nrfs; rfs++)
    9322             :     {
    9323           0 :         if( terminatenexttime )
    9324             :         {
    9325           0 :             break;
    9326             :         }
    9327             :         
    9328             :         /*
    9329             :          * calculate right part
    9330             :          */
    9331           0 :         if( rfs==0 )
    9332             :         {
    9333           0 :             ae_v_move(&rp.ptr.p_double[0], 1, &b->ptr.p_double[0], 1, ae_v_len(0,nrows-1));
    9334             :         }
    9335             :         else
    9336             :         {
    9337           0 :             smallerr = ae_true;
    9338           0 :             for(i=0; i<=nrows-1; i++)
    9339             :             {
    9340           0 :                 ae_v_move(&ta.ptr.p_double[0], 1, &a->ptr.pp_double[i][0], 1, ae_v_len(0,ncols-1));
    9341           0 :                 ta.ptr.p_double[ncols] = (double)(-1);
    9342           0 :                 ae_v_move(&tx.ptr.p_double[0], 1, &x->ptr.p_double[0], 1, ae_v_len(0,ncols-1));
    9343           0 :                 tx.ptr.p_double[ncols] = b->ptr.p_double[i];
    9344           0 :                 xdot(&ta, &tx, ncols+1, &buf, &v, &verr, _state);
    9345           0 :                 rp.ptr.p_double[i] = -v;
    9346           0 :                 smallerr = smallerr&&ae_fp_less(ae_fabs(v, _state),4*verr);
    9347             :             }
    9348           0 :             if( smallerr )
    9349             :             {
    9350           0 :                 terminatenexttime = ae_true;
    9351             :             }
    9352             :         }
    9353             :         
    9354             :         /*
    9355             :          * solve A*dx = rp
    9356             :          */
    9357           0 :         for(i=0; i<=ncols-1; i++)
    9358             :         {
    9359           0 :             tmp.ptr.p_double[i] = (double)(0);
    9360             :         }
    9361           0 :         for(i=0; i<=nsv-1; i++)
    9362             :         {
    9363           0 :             utb.ptr.p_double[i] = (double)(0);
    9364             :         }
    9365           0 :         for(i=0; i<=nrows-1; i++)
    9366             :         {
    9367           0 :             v = rp.ptr.p_double[i];
    9368           0 :             ae_v_addd(&utb.ptr.p_double[0], 1, &u.ptr.pp_double[i][0], 1, ae_v_len(0,nsv-1), v);
    9369             :         }
    9370           0 :         for(i=0; i<=nsv-1; i++)
    9371             :         {
    9372           0 :             if( i<kernelidx )
    9373             :             {
    9374           0 :                 sutb.ptr.p_double[i] = utb.ptr.p_double[i]/sv.ptr.p_double[i];
    9375             :             }
    9376             :             else
    9377             :             {
    9378           0 :                 sutb.ptr.p_double[i] = (double)(0);
    9379             :             }
    9380             :         }
    9381           0 :         for(i=0; i<=nsv-1; i++)
    9382             :         {
    9383           0 :             v = sutb.ptr.p_double[i];
    9384           0 :             ae_v_addd(&tmp.ptr.p_double[0], 1, &vt.ptr.pp_double[i][0], 1, ae_v_len(0,ncols-1), v);
    9385             :         }
    9386             :         
    9387             :         /*
    9388             :          * update x:  x:=x+dx
    9389             :          */
    9390           0 :         ae_v_add(&x->ptr.p_double[0], 1, &tmp.ptr.p_double[0], 1, ae_v_len(0,ncols-1));
    9391             :     }
    9392             :     
    9393             :     /*
    9394             :      * fill CX
    9395             :      */
    9396           0 :     if( rep->k>0 )
    9397             :     {
    9398           0 :         ae_matrix_set_length(&rep->cx, ncols, rep->k, _state);
    9399           0 :         for(i=0; i<=rep->k-1; i++)
    9400             :         {
    9401           0 :             ae_v_move(&rep->cx.ptr.pp_double[0][i], rep->cx.stride, &vt.ptr.pp_double[kernelidx+i][0], 1, ae_v_len(0,ncols-1));
    9402             :         }
    9403             :     }
    9404           0 :     ae_frame_leave(_state);
    9405             : }
    9406             : 
    9407             : 
    9408             : /*************************************************************************
    9409             : Internal LU solver
    9410             : 
    9411             :   -- ALGLIB --
    9412             :      Copyright 27.01.2010 by Bochkanov Sergey
    9413             : *************************************************************************/
    9414           0 : static void directdensesolvers_rmatrixlusolveinternal(/* Real    */ ae_matrix* lua,
    9415             :      /* Integer */ ae_vector* p,
    9416             :      ae_int_t n,
    9417             :      /* Real    */ ae_matrix* a,
    9418             :      ae_bool havea,
    9419             :      /* Real    */ ae_matrix* b,
    9420             :      ae_int_t m,
    9421             :      ae_int_t* info,
    9422             :      densesolverreport* rep,
    9423             :      /* Real    */ ae_matrix* x,
    9424             :      ae_state *_state)
    9425             : {
    9426             :     ae_frame _frame_block;
    9427             :     ae_int_t i;
    9428             :     ae_int_t j;
    9429             :     ae_int_t k;
    9430             :     ae_int_t rfs;
    9431             :     ae_int_t nrfs;
    9432             :     ae_vector xc;
    9433             :     ae_vector y;
    9434             :     ae_vector bc;
    9435             :     ae_vector xa;
    9436             :     ae_vector xb;
    9437             :     ae_vector tx;
    9438             :     double v;
    9439             :     double verr;
    9440             :     double mxb;
    9441             :     ae_bool smallerr;
    9442             :     ae_bool terminatenexttime;
    9443             : 
    9444           0 :     ae_frame_make(_state, &_frame_block);
    9445           0 :     memset(&xc, 0, sizeof(xc));
    9446           0 :     memset(&y, 0, sizeof(y));
    9447           0 :     memset(&bc, 0, sizeof(bc));
    9448           0 :     memset(&xa, 0, sizeof(xa));
    9449           0 :     memset(&xb, 0, sizeof(xb));
    9450           0 :     memset(&tx, 0, sizeof(tx));
    9451           0 :     *info = 0;
    9452           0 :     _densesolverreport_clear(rep);
    9453           0 :     ae_matrix_clear(x);
    9454           0 :     ae_vector_init(&xc, 0, DT_REAL, _state, ae_true);
    9455           0 :     ae_vector_init(&y, 0, DT_REAL, _state, ae_true);
    9456           0 :     ae_vector_init(&bc, 0, DT_REAL, _state, ae_true);
    9457           0 :     ae_vector_init(&xa, 0, DT_REAL, _state, ae_true);
    9458           0 :     ae_vector_init(&xb, 0, DT_REAL, _state, ae_true);
    9459           0 :     ae_vector_init(&tx, 0, DT_REAL, _state, ae_true);
    9460             : 
    9461             :     
    9462             :     /*
    9463             :      * prepare: check inputs, allocate space...
    9464             :      */
    9465           0 :     if( n<=0||m<=0 )
    9466             :     {
    9467           0 :         *info = -1;
    9468           0 :         ae_frame_leave(_state);
    9469           0 :         return;
    9470             :     }
    9471           0 :     for(i=0; i<=n-1; i++)
    9472             :     {
    9473           0 :         if( p->ptr.p_int[i]>n-1||p->ptr.p_int[i]<i )
    9474             :         {
    9475           0 :             *info = -1;
    9476           0 :             ae_frame_leave(_state);
    9477           0 :             return;
    9478             :         }
    9479             :     }
    9480           0 :     ae_matrix_set_length(x, n, m, _state);
    9481           0 :     ae_vector_set_length(&y, n, _state);
    9482           0 :     ae_vector_set_length(&xc, n, _state);
    9483           0 :     ae_vector_set_length(&bc, n, _state);
    9484           0 :     ae_vector_set_length(&tx, n+1, _state);
    9485           0 :     ae_vector_set_length(&xa, n+1, _state);
    9486           0 :     ae_vector_set_length(&xb, n+1, _state);
    9487             :     
    9488             :     /*
    9489             :      * estimate condition number, test for near singularity
    9490             :      */
    9491           0 :     rep->r1 = rmatrixlurcond1(lua, n, _state);
    9492           0 :     rep->rinf = rmatrixlurcondinf(lua, n, _state);
    9493           0 :     if( ae_fp_less(rep->r1,rcondthreshold(_state))||ae_fp_less(rep->rinf,rcondthreshold(_state)) )
    9494             :     {
    9495           0 :         for(i=0; i<=n-1; i++)
    9496             :         {
    9497           0 :             for(j=0; j<=m-1; j++)
    9498             :             {
    9499           0 :                 x->ptr.pp_double[i][j] = (double)(0);
    9500             :             }
    9501             :         }
    9502           0 :         rep->r1 = (double)(0);
    9503           0 :         rep->rinf = (double)(0);
    9504           0 :         *info = -3;
    9505           0 :         ae_frame_leave(_state);
    9506           0 :         return;
    9507             :     }
    9508           0 :     *info = 1;
    9509             :     
    9510             :     /*
    9511             :      * First stage of solution: rough solution with TRSM()
    9512             :      */
    9513           0 :     mxb = 0.0;
    9514           0 :     for(i=0; i<=n-1; i++)
    9515             :     {
    9516           0 :         for(j=0; j<=m-1; j++)
    9517             :         {
    9518           0 :             v = b->ptr.pp_double[i][j];
    9519           0 :             mxb = ae_maxreal(mxb, ae_fabs(v, _state), _state);
    9520           0 :             x->ptr.pp_double[i][j] = v;
    9521             :         }
    9522             :     }
    9523           0 :     for(i=0; i<=n-1; i++)
    9524             :     {
    9525           0 :         if( p->ptr.p_int[i]!=i )
    9526             :         {
    9527           0 :             for(j=0; j<=m-1; j++)
    9528             :             {
    9529           0 :                 v = x->ptr.pp_double[i][j];
    9530           0 :                 x->ptr.pp_double[i][j] = x->ptr.pp_double[p->ptr.p_int[i]][j];
    9531           0 :                 x->ptr.pp_double[p->ptr.p_int[i]][j] = v;
    9532             :             }
    9533             :         }
    9534             :     }
    9535           0 :     rmatrixlefttrsm(n, m, lua, 0, 0, ae_false, ae_true, 0, x, 0, 0, _state);
    9536           0 :     rmatrixlefttrsm(n, m, lua, 0, 0, ae_true, ae_false, 0, x, 0, 0, _state);
    9537             :     
    9538             :     /*
    9539             :      * Second stage: iterative refinement
    9540             :      */
    9541           0 :     if( havea )
    9542             :     {
    9543           0 :         for(k=0; k<=m-1; k++)
    9544             :         {
    9545           0 :             nrfs = directdensesolvers_densesolverrfsmax(n, rep->r1, rep->rinf, _state);
    9546           0 :             terminatenexttime = ae_false;
    9547           0 :             for(rfs=0; rfs<=nrfs-1; rfs++)
    9548             :             {
    9549           0 :                 if( terminatenexttime )
    9550             :                 {
    9551           0 :                     break;
    9552             :                 }
    9553             :                 
    9554             :                 /*
    9555             :                  * generate right part
    9556             :                  */
    9557           0 :                 smallerr = ae_true;
    9558           0 :                 ae_v_move(&xb.ptr.p_double[0], 1, &x->ptr.pp_double[0][k], x->stride, ae_v_len(0,n-1));
    9559           0 :                 for(i=0; i<=n-1; i++)
    9560             :                 {
    9561           0 :                     ae_v_move(&xa.ptr.p_double[0], 1, &a->ptr.pp_double[i][0], 1, ae_v_len(0,n-1));
    9562           0 :                     xa.ptr.p_double[n] = (double)(-1);
    9563           0 :                     xb.ptr.p_double[n] = b->ptr.pp_double[i][k];
    9564           0 :                     xdot(&xa, &xb, n+1, &tx, &v, &verr, _state);
    9565           0 :                     y.ptr.p_double[i] = -v;
    9566           0 :                     smallerr = smallerr&&ae_fp_less(ae_fabs(v, _state),4*verr);
    9567             :                 }
    9568           0 :                 if( smallerr )
    9569             :                 {
    9570           0 :                     terminatenexttime = ae_true;
    9571             :                 }
    9572             :                 
    9573             :                 /*
    9574             :                  * solve and update
    9575             :                  */
    9576           0 :                 directdensesolvers_rbasiclusolve(lua, p, n, &y, _state);
    9577           0 :                 ae_v_add(&x->ptr.pp_double[0][k], x->stride, &y.ptr.p_double[0], 1, ae_v_len(0,n-1));
    9578             :             }
    9579             :         }
    9580             :     }
    9581           0 :     ae_frame_leave(_state);
    9582             : }
    9583             : 
    9584             : 
    9585             : /*************************************************************************
    9586             : Internal Cholesky solver
    9587             : 
    9588             :   -- ALGLIB --
    9589             :      Copyright 27.01.2010 by Bochkanov Sergey
    9590             : *************************************************************************/
    9591           0 : static void directdensesolvers_spdmatrixcholeskysolveinternal(/* Real    */ ae_matrix* cha,
    9592             :      ae_int_t n,
    9593             :      ae_bool isupper,
    9594             :      /* Real    */ ae_matrix* a,
    9595             :      ae_bool havea,
    9596             :      /* Real    */ ae_matrix* b,
    9597             :      ae_int_t m,
    9598             :      ae_int_t* info,
    9599             :      densesolverreport* rep,
    9600             :      /* Real    */ ae_matrix* x,
    9601             :      ae_state *_state)
    9602             : {
    9603             :     ae_int_t i;
    9604             :     ae_int_t j;
    9605             : 
    9606           0 :     *info = 0;
    9607           0 :     _densesolverreport_clear(rep);
    9608           0 :     ae_matrix_clear(x);
    9609             : 
    9610             :     
    9611             :     /*
    9612             :      * prepare: check inputs, allocate space...
    9613             :      */
    9614           0 :     if( n<=0||m<=0 )
    9615             :     {
    9616           0 :         *info = -1;
    9617           0 :         return;
    9618             :     }
    9619           0 :     ae_matrix_set_length(x, n, m, _state);
    9620             :     
    9621             :     /*
    9622             :      * estimate condition number, test for near singularity
    9623             :      */
    9624           0 :     rep->r1 = spdmatrixcholeskyrcond(cha, n, isupper, _state);
    9625           0 :     rep->rinf = rep->r1;
    9626           0 :     if( ae_fp_less(rep->r1,rcondthreshold(_state)) )
    9627             :     {
    9628           0 :         for(i=0; i<=n-1; i++)
    9629             :         {
    9630           0 :             for(j=0; j<=m-1; j++)
    9631             :             {
    9632           0 :                 x->ptr.pp_double[i][j] = (double)(0);
    9633             :             }
    9634             :         }
    9635           0 :         rep->r1 = (double)(0);
    9636           0 :         rep->rinf = (double)(0);
    9637           0 :         *info = -3;
    9638           0 :         return;
    9639             :     }
    9640           0 :     *info = 1;
    9641             :     
    9642             :     /*
    9643             :      * Solve with TRSM()
    9644             :      */
    9645           0 :     for(i=0; i<=n-1; i++)
    9646             :     {
    9647           0 :         for(j=0; j<=m-1; j++)
    9648             :         {
    9649           0 :             x->ptr.pp_double[i][j] = b->ptr.pp_double[i][j];
    9650             :         }
    9651             :     }
    9652           0 :     if( isupper )
    9653             :     {
    9654           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 1, x, 0, 0, _state);
    9655           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 0, x, 0, 0, _state);
    9656             :     }
    9657             :     else
    9658             :     {
    9659           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 0, x, 0, 0, _state);
    9660           0 :         rmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 1, x, 0, 0, _state);
    9661             :     }
    9662             : }
    9663             : 
    9664             : 
    9665             : /*************************************************************************
    9666             : Internal LU solver
    9667             : 
    9668             :   -- ALGLIB --
    9669             :      Copyright 27.01.2010 by Bochkanov Sergey
    9670             : *************************************************************************/
    9671           0 : static void directdensesolvers_cmatrixlusolveinternal(/* Complex */ ae_matrix* lua,
    9672             :      /* Integer */ ae_vector* p,
    9673             :      ae_int_t n,
    9674             :      /* Complex */ ae_matrix* a,
    9675             :      ae_bool havea,
    9676             :      /* Complex */ ae_matrix* b,
    9677             :      ae_int_t m,
    9678             :      ae_int_t* info,
    9679             :      densesolverreport* rep,
    9680             :      /* Complex */ ae_matrix* x,
    9681             :      ae_state *_state)
    9682             : {
    9683             :     ae_frame _frame_block;
    9684             :     ae_int_t i;
    9685             :     ae_int_t j;
    9686             :     ae_int_t k;
    9687             :     ae_int_t rfs;
    9688             :     ae_int_t nrfs;
    9689             :     ae_vector xc;
    9690             :     ae_vector y;
    9691             :     ae_vector bc;
    9692             :     ae_vector xa;
    9693             :     ae_vector xb;
    9694             :     ae_vector tx;
    9695             :     ae_vector tmpbuf;
    9696             :     ae_complex v;
    9697             :     double verr;
    9698             :     ae_bool smallerr;
    9699             :     ae_bool terminatenexttime;
    9700             : 
    9701           0 :     ae_frame_make(_state, &_frame_block);
    9702           0 :     memset(&xc, 0, sizeof(xc));
    9703           0 :     memset(&y, 0, sizeof(y));
    9704           0 :     memset(&bc, 0, sizeof(bc));
    9705           0 :     memset(&xa, 0, sizeof(xa));
    9706           0 :     memset(&xb, 0, sizeof(xb));
    9707           0 :     memset(&tx, 0, sizeof(tx));
    9708           0 :     memset(&tmpbuf, 0, sizeof(tmpbuf));
    9709           0 :     *info = 0;
    9710           0 :     _densesolverreport_clear(rep);
    9711           0 :     ae_matrix_clear(x);
    9712           0 :     ae_vector_init(&xc, 0, DT_COMPLEX, _state, ae_true);
    9713           0 :     ae_vector_init(&y, 0, DT_COMPLEX, _state, ae_true);
    9714           0 :     ae_vector_init(&bc, 0, DT_COMPLEX, _state, ae_true);
    9715           0 :     ae_vector_init(&xa, 0, DT_COMPLEX, _state, ae_true);
    9716           0 :     ae_vector_init(&xb, 0, DT_COMPLEX, _state, ae_true);
    9717           0 :     ae_vector_init(&tx, 0, DT_COMPLEX, _state, ae_true);
    9718           0 :     ae_vector_init(&tmpbuf, 0, DT_REAL, _state, ae_true);
    9719             : 
    9720             :     
    9721             :     /*
    9722             :      * prepare: check inputs, allocate space...
    9723             :      */
    9724           0 :     if( n<=0||m<=0 )
    9725             :     {
    9726           0 :         *info = -1;
    9727           0 :         ae_frame_leave(_state);
    9728           0 :         return;
    9729             :     }
    9730           0 :     for(i=0; i<=n-1; i++)
    9731             :     {
    9732           0 :         if( p->ptr.p_int[i]>n-1||p->ptr.p_int[i]<i )
    9733             :         {
    9734           0 :             *info = -1;
    9735           0 :             ae_frame_leave(_state);
    9736           0 :             return;
    9737             :         }
    9738             :     }
    9739           0 :     ae_matrix_set_length(x, n, m, _state);
    9740           0 :     ae_vector_set_length(&y, n, _state);
    9741           0 :     ae_vector_set_length(&xc, n, _state);
    9742           0 :     ae_vector_set_length(&bc, n, _state);
    9743           0 :     ae_vector_set_length(&tx, n, _state);
    9744           0 :     ae_vector_set_length(&xa, n+1, _state);
    9745           0 :     ae_vector_set_length(&xb, n+1, _state);
    9746           0 :     ae_vector_set_length(&tmpbuf, 2*n+2, _state);
    9747             :     
    9748             :     /*
    9749             :      * estimate condition number, test for near singularity
    9750             :      */
    9751           0 :     rep->r1 = cmatrixlurcond1(lua, n, _state);
    9752           0 :     rep->rinf = cmatrixlurcondinf(lua, n, _state);
    9753           0 :     if( ae_fp_less(rep->r1,rcondthreshold(_state))||ae_fp_less(rep->rinf,rcondthreshold(_state)) )
    9754             :     {
    9755           0 :         for(i=0; i<=n-1; i++)
    9756             :         {
    9757           0 :             for(j=0; j<=m-1; j++)
    9758             :             {
    9759           0 :                 x->ptr.pp_complex[i][j] = ae_complex_from_i(0);
    9760             :             }
    9761             :         }
    9762           0 :         rep->r1 = (double)(0);
    9763           0 :         rep->rinf = (double)(0);
    9764           0 :         *info = -3;
    9765           0 :         ae_frame_leave(_state);
    9766           0 :         return;
    9767             :     }
    9768           0 :     *info = 1;
    9769             :     
    9770             :     /*
    9771             :      * First phase: solve with TRSM()
    9772             :      */
    9773           0 :     for(i=0; i<=n-1; i++)
    9774             :     {
    9775           0 :         for(j=0; j<=m-1; j++)
    9776             :         {
    9777           0 :             x->ptr.pp_complex[i][j] = b->ptr.pp_complex[i][j];
    9778             :         }
    9779             :     }
    9780           0 :     for(i=0; i<=n-1; i++)
    9781             :     {
    9782           0 :         if( p->ptr.p_int[i]!=i )
    9783             :         {
    9784           0 :             for(j=0; j<=m-1; j++)
    9785             :             {
    9786           0 :                 v = x->ptr.pp_complex[i][j];
    9787           0 :                 x->ptr.pp_complex[i][j] = x->ptr.pp_complex[p->ptr.p_int[i]][j];
    9788           0 :                 x->ptr.pp_complex[p->ptr.p_int[i]][j] = v;
    9789             :             }
    9790             :         }
    9791             :     }
    9792           0 :     cmatrixlefttrsm(n, m, lua, 0, 0, ae_false, ae_true, 0, x, 0, 0, _state);
    9793           0 :     cmatrixlefttrsm(n, m, lua, 0, 0, ae_true, ae_false, 0, x, 0, 0, _state);
    9794             :     
    9795             :     /*
    9796             :      * solve
    9797             :      */
    9798           0 :     for(k=0; k<=m-1; k++)
    9799             :     {
    9800           0 :         ae_v_cmove(&bc.ptr.p_complex[0], 1, &b->ptr.pp_complex[0][k], b->stride, "N", ae_v_len(0,n-1));
    9801           0 :         ae_v_cmove(&xc.ptr.p_complex[0], 1, &x->ptr.pp_complex[0][k], x->stride, "N", ae_v_len(0,n-1));
    9802             :         
    9803             :         /*
    9804             :          * Iterative refinement of xc:
    9805             :          * * calculate r = bc-A*xc using extra-precise dot product
    9806             :          * * solve A*y = r
    9807             :          * * update x:=x+r
    9808             :          *
    9809             :          * This cycle is executed until one of two things happens:
    9810             :          * 1. maximum number of iterations reached
    9811             :          * 2. last iteration decreased error to the lower limit
    9812             :          */
    9813           0 :         if( havea )
    9814             :         {
    9815           0 :             nrfs = directdensesolvers_densesolverrfsmax(n, rep->r1, rep->rinf, _state);
    9816           0 :             terminatenexttime = ae_false;
    9817           0 :             for(rfs=0; rfs<=nrfs-1; rfs++)
    9818             :             {
    9819           0 :                 if( terminatenexttime )
    9820             :                 {
    9821           0 :                     break;
    9822             :                 }
    9823             :                 
    9824             :                 /*
    9825             :                  * generate right part
    9826             :                  */
    9827           0 :                 smallerr = ae_true;
    9828           0 :                 ae_v_cmove(&xb.ptr.p_complex[0], 1, &xc.ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    9829           0 :                 for(i=0; i<=n-1; i++)
    9830             :                 {
    9831           0 :                     ae_v_cmove(&xa.ptr.p_complex[0], 1, &a->ptr.pp_complex[i][0], 1, "N", ae_v_len(0,n-1));
    9832           0 :                     xa.ptr.p_complex[n] = ae_complex_from_i(-1);
    9833           0 :                     xb.ptr.p_complex[n] = bc.ptr.p_complex[i];
    9834           0 :                     xcdot(&xa, &xb, n+1, &tmpbuf, &v, &verr, _state);
    9835           0 :                     y.ptr.p_complex[i] = ae_c_neg(v);
    9836           0 :                     smallerr = smallerr&&ae_fp_less(ae_c_abs(v, _state),4*verr);
    9837             :                 }
    9838           0 :                 if( smallerr )
    9839             :                 {
    9840           0 :                     terminatenexttime = ae_true;
    9841             :                 }
    9842             :                 
    9843             :                 /*
    9844             :                  * solve and update
    9845             :                  */
    9846           0 :                 directdensesolvers_cbasiclusolve(lua, p, n, &y, _state);
    9847           0 :                 ae_v_cadd(&xc.ptr.p_complex[0], 1, &y.ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    9848             :             }
    9849             :         }
    9850             :         
    9851             :         /*
    9852             :          * Store xc.
    9853             :          * Post-scale result.
    9854             :          */
    9855           0 :         ae_v_cmove(&x->ptr.pp_complex[0][k], x->stride, &xc.ptr.p_complex[0], 1, "N", ae_v_len(0,n-1));
    9856             :     }
    9857           0 :     ae_frame_leave(_state);
    9858             : }
    9859             : 
    9860             : 
    9861             : /*************************************************************************
    9862             : Internal Cholesky solver
    9863             : 
    9864             :   -- ALGLIB --
    9865             :      Copyright 27.01.2010 by Bochkanov Sergey
    9866             : *************************************************************************/
    9867           0 : static void directdensesolvers_hpdmatrixcholeskysolveinternal(/* Complex */ ae_matrix* cha,
    9868             :      ae_int_t n,
    9869             :      ae_bool isupper,
    9870             :      /* Complex */ ae_matrix* a,
    9871             :      ae_bool havea,
    9872             :      /* Complex */ ae_matrix* b,
    9873             :      ae_int_t m,
    9874             :      ae_int_t* info,
    9875             :      densesolverreport* rep,
    9876             :      /* Complex */ ae_matrix* x,
    9877             :      ae_state *_state)
    9878             : {
    9879             :     ae_frame _frame_block;
    9880             :     ae_int_t i;
    9881             :     ae_int_t j;
    9882             :     ae_vector xc;
    9883             :     ae_vector y;
    9884             :     ae_vector bc;
    9885             :     ae_vector xa;
    9886             :     ae_vector xb;
    9887             :     ae_vector tx;
    9888             : 
    9889           0 :     ae_frame_make(_state, &_frame_block);
    9890           0 :     memset(&xc, 0, sizeof(xc));
    9891           0 :     memset(&y, 0, sizeof(y));
    9892           0 :     memset(&bc, 0, sizeof(bc));
    9893           0 :     memset(&xa, 0, sizeof(xa));
    9894           0 :     memset(&xb, 0, sizeof(xb));
    9895           0 :     memset(&tx, 0, sizeof(tx));
    9896           0 :     *info = 0;
    9897           0 :     _densesolverreport_clear(rep);
    9898           0 :     ae_matrix_clear(x);
    9899           0 :     ae_vector_init(&xc, 0, DT_COMPLEX, _state, ae_true);
    9900           0 :     ae_vector_init(&y, 0, DT_COMPLEX, _state, ae_true);
    9901           0 :     ae_vector_init(&bc, 0, DT_COMPLEX, _state, ae_true);
    9902           0 :     ae_vector_init(&xa, 0, DT_COMPLEX, _state, ae_true);
    9903           0 :     ae_vector_init(&xb, 0, DT_COMPLEX, _state, ae_true);
    9904           0 :     ae_vector_init(&tx, 0, DT_COMPLEX, _state, ae_true);
    9905             : 
    9906             :     
    9907             :     /*
    9908             :      * prepare: check inputs, allocate space...
    9909             :      */
    9910           0 :     if( n<=0||m<=0 )
    9911             :     {
    9912           0 :         *info = -1;
    9913           0 :         ae_frame_leave(_state);
    9914           0 :         return;
    9915             :     }
    9916           0 :     ae_matrix_set_length(x, n, m, _state);
    9917           0 :     ae_vector_set_length(&y, n, _state);
    9918           0 :     ae_vector_set_length(&xc, n, _state);
    9919           0 :     ae_vector_set_length(&bc, n, _state);
    9920           0 :     ae_vector_set_length(&tx, n+1, _state);
    9921           0 :     ae_vector_set_length(&xa, n+1, _state);
    9922           0 :     ae_vector_set_length(&xb, n+1, _state);
    9923             :     
    9924             :     /*
    9925             :      * estimate condition number, test for near singularity
    9926             :      */
    9927           0 :     rep->r1 = hpdmatrixcholeskyrcond(cha, n, isupper, _state);
    9928           0 :     rep->rinf = rep->r1;
    9929           0 :     if( ae_fp_less(rep->r1,rcondthreshold(_state)) )
    9930             :     {
    9931           0 :         for(i=0; i<=n-1; i++)
    9932             :         {
    9933           0 :             for(j=0; j<=m-1; j++)
    9934             :             {
    9935           0 :                 x->ptr.pp_complex[i][j] = ae_complex_from_i(0);
    9936             :             }
    9937             :         }
    9938           0 :         rep->r1 = (double)(0);
    9939           0 :         rep->rinf = (double)(0);
    9940           0 :         *info = -3;
    9941           0 :         ae_frame_leave(_state);
    9942           0 :         return;
    9943             :     }
    9944           0 :     *info = 1;
    9945             :     
    9946             :     /*
    9947             :      * solve
    9948             :      */
    9949           0 :     for(i=0; i<=n-1; i++)
    9950             :     {
    9951           0 :         for(j=0; j<=m-1; j++)
    9952             :         {
    9953           0 :             x->ptr.pp_complex[i][j] = b->ptr.pp_complex[i][j];
    9954             :         }
    9955             :     }
    9956           0 :     if( isupper )
    9957             :     {
    9958           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 2, x, 0, 0, _state);
    9959           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_true, ae_false, 0, x, 0, 0, _state);
    9960             :     }
    9961             :     else
    9962             :     {
    9963           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 0, x, 0, 0, _state);
    9964           0 :         cmatrixlefttrsm(n, m, cha, 0, 0, ae_false, ae_false, 2, x, 0, 0, _state);
    9965             :     }
    9966           0 :     ae_frame_leave(_state);
    9967             : }
    9968             : 
    9969             : 
    9970             : /*************************************************************************
    9971             : Internal subroutine.
    9972             : Returns maximum count of RFS iterations as function of:
    9973             : 1. machine epsilon
    9974             : 2. task size.
    9975             : 3. condition number
    9976             : 
    9977             :   -- ALGLIB --
    9978             :      Copyright 27.01.2010 by Bochkanov Sergey
    9979             : *************************************************************************/
    9980           0 : static ae_int_t directdensesolvers_densesolverrfsmax(ae_int_t n,
    9981             :      double r1,
    9982             :      double rinf,
    9983             :      ae_state *_state)
    9984             : {
    9985             :     ae_int_t result;
    9986             : 
    9987             : 
    9988           0 :     result = 5;
    9989           0 :     return result;
    9990             : }
    9991             : 
    9992             : 
    9993             : /*************************************************************************
    9994             : Internal subroutine.
    9995             : Returns maximum count of RFS iterations as function of:
    9996             : 1. machine epsilon
    9997             : 2. task size.
    9998             : 3. norm-2 condition number
    9999             : 
   10000             :   -- ALGLIB --
   10001             :      Copyright 27.01.2010 by Bochkanov Sergey
   10002             : *************************************************************************/
   10003           0 : static ae_int_t directdensesolvers_densesolverrfsmaxv2(ae_int_t n,
   10004             :      double r2,
   10005             :      ae_state *_state)
   10006             : {
   10007             :     ae_int_t result;
   10008             : 
   10009             : 
   10010           0 :     result = directdensesolvers_densesolverrfsmax(n, (double)(0), (double)(0), _state);
   10011           0 :     return result;
   10012             : }
   10013             : 
   10014             : 
   10015             : /*************************************************************************
   10016             : Basic LU solver for PLU*x = y.
   10017             : 
   10018             : This subroutine assumes that:
   10019             : * A=PLU is well-conditioned, so no zero divisions or overflow may occur
   10020             : 
   10021             :   -- ALGLIB --
   10022             :      Copyright 27.01.2010 by Bochkanov Sergey
   10023             : *************************************************************************/
   10024           0 : static void directdensesolvers_rbasiclusolve(/* Real    */ ae_matrix* lua,
   10025             :      /* Integer */ ae_vector* p,
   10026             :      ae_int_t n,
   10027             :      /* Real    */ ae_vector* xb,
   10028             :      ae_state *_state)
   10029             : {
   10030             :     ae_int_t i;
   10031             :     double v;
   10032             : 
   10033             : 
   10034           0 :     for(i=0; i<=n-1; i++)
   10035             :     {
   10036           0 :         if( p->ptr.p_int[i]!=i )
   10037             :         {
   10038           0 :             v = xb->ptr.p_double[i];
   10039           0 :             xb->ptr.p_double[i] = xb->ptr.p_double[p->ptr.p_int[i]];
   10040           0 :             xb->ptr.p_double[p->ptr.p_int[i]] = v;
   10041             :         }
   10042             :     }
   10043           0 :     for(i=1; i<=n-1; i++)
   10044             :     {
   10045           0 :         v = ae_v_dotproduct(&lua->ptr.pp_double[i][0], 1, &xb->ptr.p_double[0], 1, ae_v_len(0,i-1));
   10046           0 :         xb->ptr.p_double[i] = xb->ptr.p_double[i]-v;
   10047             :     }
   10048           0 :     xb->ptr.p_double[n-1] = xb->ptr.p_double[n-1]/lua->ptr.pp_double[n-1][n-1];
   10049           0 :     for(i=n-2; i>=0; i--)
   10050             :     {
   10051           0 :         v = ae_v_dotproduct(&lua->ptr.pp_double[i][i+1], 1, &xb->ptr.p_double[i+1], 1, ae_v_len(i+1,n-1));
   10052           0 :         xb->ptr.p_double[i] = (xb->ptr.p_double[i]-v)/lua->ptr.pp_double[i][i];
   10053             :     }
   10054           0 : }
   10055             : 
   10056             : 
   10057             : /*************************************************************************
   10058             : Basic Cholesky solver for ScaleA*Cholesky(A)'*x = y.
   10059             : 
   10060             : This subroutine assumes that:
   10061             : * A*ScaleA is well scaled
   10062             : * A is well-conditioned, so no zero divisions or overflow may occur
   10063             : 
   10064             :   -- ALGLIB --
   10065             :      Copyright 27.01.2010 by Bochkanov Sergey
   10066             : *************************************************************************/
   10067           0 : static void directdensesolvers_spdbasiccholeskysolve(/* Real    */ ae_matrix* cha,
   10068             :      ae_int_t n,
   10069             :      ae_bool isupper,
   10070             :      /* Real    */ ae_vector* xb,
   10071             :      ae_state *_state)
   10072             : {
   10073             :     ae_int_t i;
   10074             :     double v;
   10075             : 
   10076             : 
   10077             :     
   10078             :     /*
   10079             :      * A = L*L' or A=U'*U
   10080             :      */
   10081           0 :     if( isupper )
   10082             :     {
   10083             :         
   10084             :         /*
   10085             :          * Solve U'*y=b first.
   10086             :          */
   10087           0 :         for(i=0; i<=n-1; i++)
   10088             :         {
   10089           0 :             xb->ptr.p_double[i] = xb->ptr.p_double[i]/cha->ptr.pp_double[i][i];
   10090           0 :             if( i<n-1 )
   10091             :             {
   10092           0 :                 v = xb->ptr.p_double[i];
   10093           0 :                 ae_v_subd(&xb->ptr.p_double[i+1], 1, &cha->ptr.pp_double[i][i+1], 1, ae_v_len(i+1,n-1), v);
   10094             :             }
   10095             :         }
   10096             :         
   10097             :         /*
   10098             :          * Solve U*x=y then.
   10099             :          */
   10100           0 :         for(i=n-1; i>=0; i--)
   10101             :         {
   10102           0 :             if( i<n-1 )
   10103             :             {
   10104           0 :                 v = ae_v_dotproduct(&cha->ptr.pp_double[i][i+1], 1, &xb->ptr.p_double[i+1], 1, ae_v_len(i+1,n-1));
   10105           0 :                 xb->ptr.p_double[i] = xb->ptr.p_double[i]-v;
   10106             :             }
   10107           0 :             xb->ptr.p_double[i] = xb->ptr.p_double[i]/cha->ptr.pp_double[i][i];
   10108             :         }
   10109             :     }
   10110             :     else
   10111             :     {
   10112             :         
   10113             :         /*
   10114             :          * Solve L*y=b first
   10115             :          */
   10116           0 :         for(i=0; i<=n-1; i++)
   10117             :         {
   10118           0 :             if( i>0 )
   10119             :             {
   10120           0 :                 v = ae_v_dotproduct(&cha->ptr.pp_double[i][0], 1, &xb->ptr.p_double[0], 1, ae_v_len(0,i-1));
   10121           0 :                 xb->ptr.p_double[i] = xb->ptr.p_double[i]-v;
   10122             :             }
   10123           0 :             xb->ptr.p_double[i] = xb->ptr.p_double[i]/cha->ptr.pp_double[i][i];
   10124             :         }
   10125             :         
   10126             :         /*
   10127             :          * Solve L'*x=y then.
   10128             :          */
   10129           0 :         for(i=n-1; i>=0; i--)
   10130             :         {
   10131           0 :             xb->ptr.p_double[i] = xb->ptr.p_double[i]/cha->ptr.pp_double[i][i];
   10132           0 :             if( i>0 )
   10133             :             {
   10134           0 :                 v = xb->ptr.p_double[i];
   10135           0 :                 ae_v_subd(&xb->ptr.p_double[0], 1, &cha->ptr.pp_double[i][0], 1, ae_v_len(0,i-1), v);
   10136             :             }
   10137             :         }
   10138             :     }
   10139           0 : }
   10140             : 
   10141             : 
   10142             : /*************************************************************************
   10143             : Basic LU solver for ScaleA*PLU*x = y.
   10144             : 
   10145             : This subroutine assumes that:
   10146             : * L is well-scaled, and it is U which needs scaling by ScaleA.
   10147             : * A=PLU is well-conditioned, so no zero divisions or overflow may occur
   10148             : 
   10149             :   -- ALGLIB --
   10150             :      Copyright 27.01.2010 by Bochkanov Sergey
   10151             : *************************************************************************/
   10152           0 : static void directdensesolvers_cbasiclusolve(/* Complex */ ae_matrix* lua,
   10153             :      /* Integer */ ae_vector* p,
   10154             :      ae_int_t n,
   10155             :      /* Complex */ ae_vector* xb,
   10156             :      ae_state *_state)
   10157             : {
   10158             :     ae_int_t i;
   10159             :     ae_complex v;
   10160             : 
   10161             : 
   10162           0 :     for(i=0; i<=n-1; i++)
   10163             :     {
   10164           0 :         if( p->ptr.p_int[i]!=i )
   10165             :         {
   10166           0 :             v = xb->ptr.p_complex[i];
   10167           0 :             xb->ptr.p_complex[i] = xb->ptr.p_complex[p->ptr.p_int[i]];
   10168           0 :             xb->ptr.p_complex[p->ptr.p_int[i]] = v;
   10169             :         }
   10170             :     }
   10171           0 :     for(i=1; i<=n-1; i++)
   10172             :     {
   10173           0 :         v = ae_v_cdotproduct(&lua->ptr.pp_complex[i][0], 1, "N", &xb->ptr.p_complex[0], 1, "N", ae_v_len(0,i-1));
   10174           0 :         xb->ptr.p_complex[i] = ae_c_sub(xb->ptr.p_complex[i],v);
   10175             :     }
   10176           0 :     xb->ptr.p_complex[n-1] = ae_c_div(xb->ptr.p_complex[n-1],lua->ptr.pp_complex[n-1][n-1]);
   10177           0 :     for(i=n-2; i>=0; i--)
   10178             :     {
   10179           0 :         v = ae_v_cdotproduct(&lua->ptr.pp_complex[i][i+1], 1, "N", &xb->ptr.p_complex[i+1], 1, "N", ae_v_len(i+1,n-1));
   10180           0 :         xb->ptr.p_complex[i] = ae_c_div(ae_c_sub(xb->ptr.p_complex[i],v),lua->ptr.pp_complex[i][i]);
   10181             :     }
   10182           0 : }
   10183             : 
   10184             : 
   10185             : /*************************************************************************
   10186             : Basic Cholesky solver for ScaleA*Cholesky(A)'*x = y.
   10187             : 
   10188             : This subroutine assumes that:
   10189             : * A*ScaleA is well scaled
   10190             : * A is well-conditioned, so no zero divisions or overflow may occur
   10191             : 
   10192             :   -- ALGLIB --
   10193             :      Copyright 27.01.2010 by Bochkanov Sergey
   10194             : *************************************************************************/
   10195           0 : static void directdensesolvers_hpdbasiccholeskysolve(/* Complex */ ae_matrix* cha,
   10196             :      ae_int_t n,
   10197             :      ae_bool isupper,
   10198             :      /* Complex */ ae_vector* xb,
   10199             :      ae_state *_state)
   10200             : {
   10201             :     ae_int_t i;
   10202             :     ae_complex v;
   10203             : 
   10204             : 
   10205             :     
   10206             :     /*
   10207             :      * A = L*L' or A=U'*U
   10208             :      */
   10209           0 :     if( isupper )
   10210             :     {
   10211             :         
   10212             :         /*
   10213             :          * Solve U'*y=b first.
   10214             :          */
   10215           0 :         for(i=0; i<=n-1; i++)
   10216             :         {
   10217           0 :             xb->ptr.p_complex[i] = ae_c_div(xb->ptr.p_complex[i],ae_c_conj(cha->ptr.pp_complex[i][i], _state));
   10218           0 :             if( i<n-1 )
   10219             :             {
   10220           0 :                 v = xb->ptr.p_complex[i];
   10221           0 :                 ae_v_csubc(&xb->ptr.p_complex[i+1], 1, &cha->ptr.pp_complex[i][i+1], 1, "Conj", ae_v_len(i+1,n-1), v);
   10222             :             }
   10223             :         }
   10224             :         
   10225             :         /*
   10226             :          * Solve U*x=y then.
   10227             :          */
   10228           0 :         for(i=n-1; i>=0; i--)
   10229             :         {
   10230           0 :             if( i<n-1 )
   10231             :             {
   10232           0 :                 v = ae_v_cdotproduct(&cha->ptr.pp_complex[i][i+1], 1, "N", &xb->ptr.p_complex[i+1], 1, "N", ae_v_len(i+1,n-1));
   10233           0 :                 xb->ptr.p_complex[i] = ae_c_sub(xb->ptr.p_complex[i],v);
   10234             :             }
   10235           0 :             xb->ptr.p_complex[i] = ae_c_div(xb->ptr.p_complex[i],cha->ptr.pp_complex[i][i]);
   10236             :         }
   10237             :     }
   10238             :     else
   10239             :     {
   10240             :         
   10241             :         /*
   10242             :          * Solve L*y=b first
   10243             :          */
   10244           0 :         for(i=0; i<=n-1; i++)
   10245             :         {
   10246           0 :             if( i>0 )
   10247             :             {
   10248           0 :                 v = ae_v_cdotproduct(&cha->ptr.pp_complex[i][0], 1, "N", &xb->ptr.p_complex[0], 1, "N", ae_v_len(0,i-1));
   10249           0 :                 xb->ptr.p_complex[i] = ae_c_sub(xb->ptr.p_complex[i],v);
   10250             :             }
   10251           0 :             xb->ptr.p_complex[i] = ae_c_div(xb->ptr.p_complex[i],cha->ptr.pp_complex[i][i]);
   10252             :         }
   10253             :         
   10254             :         /*
   10255             :          * Solve L'*x=y then.
   10256             :          */
   10257           0 :         for(i=n-1; i>=0; i--)
   10258             :         {
   10259           0 :             xb->ptr.p_complex[i] = ae_c_div(xb->ptr.p_complex[i],ae_c_conj(cha->ptr.pp_complex[i][i], _state));
   10260           0 :             if( i>0 )
   10261             :             {
   10262           0 :                 v = xb->ptr.p_complex[i];
   10263           0 :                 ae_v_csubc(&xb->ptr.p_complex[0], 1, &cha->ptr.pp_complex[i][0], 1, "Conj", ae_v_len(0,i-1), v);
   10264             :             }
   10265             :         }
   10266             :     }
   10267           0 : }
   10268             : 
   10269             : 
   10270           0 : void _densesolverreport_init(void* _p, ae_state *_state, ae_bool make_automatic)
   10271             : {
   10272           0 :     densesolverreport *p = (densesolverreport*)_p;
   10273           0 :     ae_touch_ptr((void*)p);
   10274           0 : }
   10275             : 
   10276             : 
   10277           0 : void _densesolverreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   10278             : {
   10279           0 :     densesolverreport *dst = (densesolverreport*)_dst;
   10280           0 :     densesolverreport *src = (densesolverreport*)_src;
   10281           0 :     dst->r1 = src->r1;
   10282           0 :     dst->rinf = src->rinf;
   10283           0 : }
   10284             : 
   10285             : 
   10286           0 : void _densesolverreport_clear(void* _p)
   10287             : {
   10288           0 :     densesolverreport *p = (densesolverreport*)_p;
   10289           0 :     ae_touch_ptr((void*)p);
   10290           0 : }
   10291             : 
   10292             : 
   10293           0 : void _densesolverreport_destroy(void* _p)
   10294             : {
   10295           0 :     densesolverreport *p = (densesolverreport*)_p;
   10296           0 :     ae_touch_ptr((void*)p);
   10297           0 : }
   10298             : 
   10299             : 
   10300           0 : void _densesolverlsreport_init(void* _p, ae_state *_state, ae_bool make_automatic)
   10301             : {
   10302           0 :     densesolverlsreport *p = (densesolverlsreport*)_p;
   10303           0 :     ae_touch_ptr((void*)p);
   10304           0 :     ae_matrix_init(&p->cx, 0, 0, DT_REAL, _state, make_automatic);
   10305           0 : }
   10306             : 
   10307             : 
   10308           0 : void _densesolverlsreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   10309             : {
   10310           0 :     densesolverlsreport *dst = (densesolverlsreport*)_dst;
   10311           0 :     densesolverlsreport *src = (densesolverlsreport*)_src;
   10312           0 :     dst->r2 = src->r2;
   10313           0 :     ae_matrix_init_copy(&dst->cx, &src->cx, _state, make_automatic);
   10314           0 :     dst->n = src->n;
   10315           0 :     dst->k = src->k;
   10316           0 : }
   10317             : 
   10318             : 
   10319           0 : void _densesolverlsreport_clear(void* _p)
   10320             : {
   10321           0 :     densesolverlsreport *p = (densesolverlsreport*)_p;
   10322           0 :     ae_touch_ptr((void*)p);
   10323           0 :     ae_matrix_clear(&p->cx);
   10324           0 : }
   10325             : 
   10326             : 
   10327           0 : void _densesolverlsreport_destroy(void* _p)
   10328             : {
   10329           0 :     densesolverlsreport *p = (densesolverlsreport*)_p;
   10330           0 :     ae_touch_ptr((void*)p);
   10331           0 :     ae_matrix_destroy(&p->cx);
   10332           0 : }
   10333             : 
   10334             : 
   10335             : #endif
   10336             : #if defined(AE_COMPILE_LINLSQR) || !defined(AE_PARTIAL_BUILD)
   10337             : 
   10338             : 
   10339             : /*************************************************************************
   10340             : This function initializes linear LSQR Solver. This solver is used to solve
   10341             : non-symmetric (and, possibly, non-square) problems. Least squares solution
   10342             : is returned for non-compatible systems.
   10343             : 
   10344             : USAGE:
   10345             : 1. User initializes algorithm state with LinLSQRCreate() call
   10346             : 2. User tunes solver parameters with  LinLSQRSetCond() and other functions
   10347             : 3. User  calls  LinLSQRSolveSparse()  function which takes algorithm state 
   10348             :    and SparseMatrix object.
   10349             : 4. User calls LinLSQRResults() to get solution
   10350             : 5. Optionally, user may call LinLSQRSolveSparse() again to  solve  another  
   10351             :    problem  with different matrix and/or right part without reinitializing 
   10352             :    LinLSQRState structure.
   10353             :   
   10354             : INPUT PARAMETERS:
   10355             :     M       -   number of rows in A
   10356             :     N       -   number of variables, N>0
   10357             : 
   10358             : OUTPUT PARAMETERS:
   10359             :     State   -   structure which stores algorithm state
   10360             :     
   10361             : NOTE: see also linlsqrcreatebuf()  for  version  which  reuses  previously
   10362             :       allocated place as much as possible.
   10363             : 
   10364             :   -- ALGLIB --
   10365             :      Copyright 30.11.2011 by Bochkanov Sergey
   10366             : *************************************************************************/
   10367           0 : void linlsqrcreate(ae_int_t m,
   10368             :      ae_int_t n,
   10369             :      linlsqrstate* state,
   10370             :      ae_state *_state)
   10371             : {
   10372             : 
   10373           0 :     _linlsqrstate_clear(state);
   10374             : 
   10375           0 :     ae_assert(m>0, "LinLSQRCreate: M<=0", _state);
   10376           0 :     ae_assert(n>0, "LinLSQRCreate: N<=0", _state);
   10377           0 :     linlsqrcreatebuf(m, n, state, _state);
   10378           0 : }
   10379             : 
   10380             : 
   10381             : /*************************************************************************
   10382             : This function initializes linear LSQR Solver.  It  provides  exactly  same
   10383             : functionality as linlsqrcreate(), but reuses  previously  allocated  space
   10384             : as much as possible.
   10385             :   
   10386             : INPUT PARAMETERS:
   10387             :     M       -   number of rows in A
   10388             :     N       -   number of variables, N>0
   10389             : 
   10390             : OUTPUT PARAMETERS:
   10391             :     State   -   structure which stores algorithm state
   10392             : 
   10393             :   -- ALGLIB --
   10394             :      Copyright 14.11.2018 by Bochkanov Sergey
   10395             : *************************************************************************/
   10396           0 : void linlsqrcreatebuf(ae_int_t m,
   10397             :      ae_int_t n,
   10398             :      linlsqrstate* state,
   10399             :      ae_state *_state)
   10400             : {
   10401             :     ae_int_t i;
   10402             : 
   10403             : 
   10404           0 :     ae_assert(m>0, "LinLSQRCreateBuf: M<=0", _state);
   10405           0 :     ae_assert(n>0, "LinLSQRCreateBuf: N<=0", _state);
   10406           0 :     state->m = m;
   10407           0 :     state->n = n;
   10408           0 :     state->prectype = 0;
   10409           0 :     state->epsa = linlsqr_atol;
   10410           0 :     state->epsb = linlsqr_btol;
   10411           0 :     state->epsc = 1/ae_sqrt(ae_machineepsilon, _state);
   10412           0 :     state->maxits = 0;
   10413           0 :     state->lambdai = (double)(0);
   10414           0 :     state->xrep = ae_false;
   10415           0 :     state->running = ae_false;
   10416           0 :     state->repiterationscount = 0;
   10417             :     
   10418             :     /*
   10419             :      * * allocate arrays
   10420             :      * * set RX to NAN (just for the case user calls Results() without 
   10421             :      *   calling SolveSparse()
   10422             :      * * set B to zero
   10423             :      */
   10424           0 :     normestimatorcreate(m, n, 2, 2, &state->nes, _state);
   10425           0 :     ae_vector_set_length(&state->rx, state->n, _state);
   10426           0 :     ae_vector_set_length(&state->ui, state->m+state->n, _state);
   10427           0 :     ae_vector_set_length(&state->uip1, state->m+state->n, _state);
   10428           0 :     ae_vector_set_length(&state->vip1, state->n, _state);
   10429           0 :     ae_vector_set_length(&state->vi, state->n, _state);
   10430           0 :     ae_vector_set_length(&state->omegai, state->n, _state);
   10431           0 :     ae_vector_set_length(&state->omegaip1, state->n, _state);
   10432           0 :     ae_vector_set_length(&state->d, state->n, _state);
   10433           0 :     ae_vector_set_length(&state->x, state->m+state->n, _state);
   10434           0 :     ae_vector_set_length(&state->mv, state->m+state->n, _state);
   10435           0 :     ae_vector_set_length(&state->mtv, state->n, _state);
   10436           0 :     ae_vector_set_length(&state->b, state->m, _state);
   10437           0 :     for(i=0; i<=n-1; i++)
   10438             :     {
   10439           0 :         state->rx.ptr.p_double[i] = _state->v_nan;
   10440             :     }
   10441           0 :     for(i=0; i<=m-1; i++)
   10442             :     {
   10443           0 :         state->b.ptr.p_double[i] = (double)(0);
   10444             :     }
   10445           0 :     ae_vector_set_length(&state->rstate.ia, 1+1, _state);
   10446           0 :     ae_vector_set_length(&state->rstate.ra, 0+1, _state);
   10447           0 :     state->rstate.stage = -1;
   10448           0 : }
   10449             : 
   10450             : 
   10451             : /*************************************************************************
   10452             : This function sets right part. By default, right part is zero.
   10453             : 
   10454             : INPUT PARAMETERS:
   10455             :     B       -   right part, array[N].
   10456             : 
   10457             : OUTPUT PARAMETERS:
   10458             :     State   -   structure which stores algorithm state
   10459             : 
   10460             :   -- ALGLIB --
   10461             :      Copyright 30.11.2011 by Bochkanov Sergey
   10462             : *************************************************************************/
   10463           0 : void linlsqrsetb(linlsqrstate* state,
   10464             :      /* Real    */ ae_vector* b,
   10465             :      ae_state *_state)
   10466             : {
   10467             :     ae_int_t i;
   10468             : 
   10469             : 
   10470           0 :     ae_assert(!state->running, "LinLSQRSetB: you can not change B when LinLSQRIteration is running", _state);
   10471           0 :     ae_assert(state->m<=b->cnt, "LinLSQRSetB: Length(B)<M", _state);
   10472           0 :     ae_assert(isfinitevector(b, state->m, _state), "LinLSQRSetB: B contains infinite or NaN values", _state);
   10473           0 :     state->bnorm2 = (double)(0);
   10474           0 :     for(i=0; i<=state->m-1; i++)
   10475             :     {
   10476           0 :         state->b.ptr.p_double[i] = b->ptr.p_double[i];
   10477           0 :         state->bnorm2 = state->bnorm2+b->ptr.p_double[i]*b->ptr.p_double[i];
   10478             :     }
   10479           0 : }
   10480             : 
   10481             : 
   10482             : /*************************************************************************
   10483             : This  function  changes  preconditioning  settings of LinLSQQSolveSparse()
   10484             : function. By default, SolveSparse() uses diagonal preconditioner,  but  if
   10485             : you want to use solver without preconditioning, you can call this function
   10486             : which forces solver to use unit matrix for preconditioning.
   10487             : 
   10488             : INPUT PARAMETERS:
   10489             :     State   -   structure which stores algorithm state
   10490             : 
   10491             :   -- ALGLIB --
   10492             :      Copyright 19.11.2012 by Bochkanov Sergey
   10493             : *************************************************************************/
   10494           0 : void linlsqrsetprecunit(linlsqrstate* state, ae_state *_state)
   10495             : {
   10496             : 
   10497             : 
   10498           0 :     ae_assert(!state->running, "LinLSQRSetPrecUnit: you can not change preconditioner, because function LinLSQRIteration is running!", _state);
   10499           0 :     state->prectype = -1;
   10500           0 : }
   10501             : 
   10502             : 
   10503             : /*************************************************************************
   10504             : This  function  changes  preconditioning  settings  of  LinCGSolveSparse()
   10505             : function.  LinCGSolveSparse() will use diagonal of the  system  matrix  as
   10506             : preconditioner. This preconditioning mode is active by default.
   10507             : 
   10508             : INPUT PARAMETERS:
   10509             :     State   -   structure which stores algorithm state
   10510             : 
   10511             :   -- ALGLIB --
   10512             :      Copyright 19.11.2012 by Bochkanov Sergey
   10513             : *************************************************************************/
   10514           0 : void linlsqrsetprecdiag(linlsqrstate* state, ae_state *_state)
   10515             : {
   10516             : 
   10517             : 
   10518           0 :     ae_assert(!state->running, "LinLSQRSetPrecDiag: you can not change preconditioner, because function LinCGIteration is running!", _state);
   10519           0 :     state->prectype = 0;
   10520           0 : }
   10521             : 
   10522             : 
   10523             : /*************************************************************************
   10524             : This function sets optional Tikhonov regularization coefficient.
   10525             : It is zero by default.
   10526             : 
   10527             : INPUT PARAMETERS:
   10528             :     LambdaI -   regularization factor, LambdaI>=0
   10529             : 
   10530             : OUTPUT PARAMETERS:
   10531             :     State   -   structure which stores algorithm state
   10532             :     
   10533             :   -- ALGLIB --
   10534             :      Copyright 30.11.2011 by Bochkanov Sergey
   10535             : *************************************************************************/
   10536           0 : void linlsqrsetlambdai(linlsqrstate* state,
   10537             :      double lambdai,
   10538             :      ae_state *_state)
   10539             : {
   10540             : 
   10541             : 
   10542           0 :     ae_assert(!state->running, "LinLSQRSetLambdaI: you can not set LambdaI, because function LinLSQRIteration is running", _state);
   10543           0 :     ae_assert(ae_isfinite(lambdai, _state)&&ae_fp_greater_eq(lambdai,(double)(0)), "LinLSQRSetLambdaI: LambdaI is infinite or NaN", _state);
   10544           0 :     state->lambdai = lambdai;
   10545           0 : }
   10546             : 
   10547             : 
   10548             : /*************************************************************************
   10549             : 
   10550             :   -- ALGLIB --
   10551             :      Copyright 30.11.2011 by Bochkanov Sergey
   10552             : *************************************************************************/
   10553           0 : ae_bool linlsqriteration(linlsqrstate* state, ae_state *_state)
   10554             : {
   10555             :     ae_int_t summn;
   10556             :     double bnorm;
   10557             :     ae_int_t i;
   10558             :     ae_bool result;
   10559             : 
   10560             : 
   10561             :     
   10562             :     /*
   10563             :      * Reverse communication preparations
   10564             :      * I know it looks ugly, but it works the same way
   10565             :      * anywhere from C++ to Python.
   10566             :      *
   10567             :      * This code initializes locals by:
   10568             :      * * random values determined during code
   10569             :      *   generation - on first subroutine call
   10570             :      * * values from previous call - on subsequent calls
   10571             :      */
   10572           0 :     if( state->rstate.stage>=0 )
   10573             :     {
   10574           0 :         summn = state->rstate.ia.ptr.p_int[0];
   10575           0 :         i = state->rstate.ia.ptr.p_int[1];
   10576           0 :         bnorm = state->rstate.ra.ptr.p_double[0];
   10577             :     }
   10578             :     else
   10579             :     {
   10580           0 :         summn = 359;
   10581           0 :         i = -58;
   10582           0 :         bnorm = -919;
   10583             :     }
   10584           0 :     if( state->rstate.stage==0 )
   10585             :     {
   10586           0 :         goto lbl_0;
   10587             :     }
   10588           0 :     if( state->rstate.stage==1 )
   10589             :     {
   10590           0 :         goto lbl_1;
   10591             :     }
   10592           0 :     if( state->rstate.stage==2 )
   10593             :     {
   10594           0 :         goto lbl_2;
   10595             :     }
   10596           0 :     if( state->rstate.stage==3 )
   10597             :     {
   10598           0 :         goto lbl_3;
   10599             :     }
   10600           0 :     if( state->rstate.stage==4 )
   10601             :     {
   10602           0 :         goto lbl_4;
   10603             :     }
   10604           0 :     if( state->rstate.stage==5 )
   10605             :     {
   10606           0 :         goto lbl_5;
   10607             :     }
   10608           0 :     if( state->rstate.stage==6 )
   10609             :     {
   10610           0 :         goto lbl_6;
   10611             :     }
   10612             :     
   10613             :     /*
   10614             :      * Routine body
   10615             :      */
   10616           0 :     ae_assert(state->b.cnt>0, "LinLSQRIteration: using non-allocated array B", _state);
   10617           0 :     summn = state->m+state->n;
   10618           0 :     bnorm = ae_sqrt(state->bnorm2, _state);
   10619           0 :     state->userterminationneeded = ae_false;
   10620           0 :     state->running = ae_true;
   10621           0 :     state->repnmv = 0;
   10622           0 :     state->repiterationscount = 0;
   10623           0 :     state->r2 = state->bnorm2;
   10624           0 :     linlsqr_clearrfields(state, _state);
   10625             :     
   10626             :     /*
   10627             :      *estimate for ANorm
   10628             :      */
   10629           0 :     normestimatorrestart(&state->nes, _state);
   10630           0 : lbl_7:
   10631           0 :     if( !normestimatoriteration(&state->nes, _state) )
   10632             :     {
   10633           0 :         goto lbl_8;
   10634             :     }
   10635           0 :     if( !state->nes.needmv )
   10636             :     {
   10637           0 :         goto lbl_9;
   10638             :     }
   10639           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->nes.x.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   10640           0 :     state->repnmv = state->repnmv+1;
   10641           0 :     linlsqr_clearrfields(state, _state);
   10642           0 :     state->needmv = ae_true;
   10643           0 :     state->rstate.stage = 0;
   10644           0 :     goto lbl_rcomm;
   10645           0 : lbl_0:
   10646           0 :     state->needmv = ae_false;
   10647           0 :     ae_v_move(&state->nes.mv.ptr.p_double[0], 1, &state->mv.ptr.p_double[0], 1, ae_v_len(0,state->m-1));
   10648           0 :     goto lbl_7;
   10649           0 : lbl_9:
   10650           0 :     if( !state->nes.needmtv )
   10651             :     {
   10652           0 :         goto lbl_11;
   10653             :     }
   10654           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->nes.x.ptr.p_double[0], 1, ae_v_len(0,state->m-1));
   10655             :     
   10656             :     /*
   10657             :      *matrix-vector multiplication
   10658             :      */
   10659           0 :     state->repnmv = state->repnmv+1;
   10660           0 :     linlsqr_clearrfields(state, _state);
   10661           0 :     state->needmtv = ae_true;
   10662           0 :     state->rstate.stage = 1;
   10663           0 :     goto lbl_rcomm;
   10664           0 : lbl_1:
   10665           0 :     state->needmtv = ae_false;
   10666           0 :     ae_v_move(&state->nes.mtv.ptr.p_double[0], 1, &state->mtv.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   10667           0 :     goto lbl_7;
   10668           0 : lbl_11:
   10669           0 :     goto lbl_7;
   10670           0 : lbl_8:
   10671           0 :     normestimatorresults(&state->nes, &state->anorm, _state);
   10672             :     
   10673             :     /*
   10674             :      *initialize .RX by zeros
   10675             :      */
   10676           0 :     for(i=0; i<=state->n-1; i++)
   10677             :     {
   10678           0 :         state->rx.ptr.p_double[i] = (double)(0);
   10679             :     }
   10680             :     
   10681             :     /*
   10682             :      *output first report
   10683             :      */
   10684           0 :     if( !state->xrep )
   10685             :     {
   10686           0 :         goto lbl_13;
   10687             :     }
   10688           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   10689           0 :     linlsqr_clearrfields(state, _state);
   10690           0 :     state->xupdated = ae_true;
   10691           0 :     state->rstate.stage = 2;
   10692           0 :     goto lbl_rcomm;
   10693           0 : lbl_2:
   10694           0 :     state->xupdated = ae_false;
   10695           0 : lbl_13:
   10696             :     
   10697             :     /*
   10698             :      * LSQR, Step 0.
   10699             :      *
   10700             :      * Algorithm outline corresponds to one which was described at p.50 of
   10701             :      * "LSQR - an algorithm for sparse linear equations and sparse least 
   10702             :      * squares" by C.Paige and M.Saunders with one small addition - we
   10703             :      * explicitly extend system matrix by additional N lines in order 
   10704             :      * to handle non-zero lambda, i.e. original A is replaced by
   10705             :      *         [ A        ]
   10706             :      * A_mod = [          ]
   10707             :      *         [ lambda*I ].
   10708             :      *
   10709             :      * Step 0:
   10710             :      *     x[0]          = 0
   10711             :      *     beta[1]*u[1]  = b
   10712             :      *     alpha[1]*v[1] = A_mod'*u[1]
   10713             :      *     w[1]          = v[1]
   10714             :      *     phiBar[1]     = beta[1]
   10715             :      *     rhoBar[1]     = alpha[1]
   10716             :      *     d[0]          = 0
   10717             :      *
   10718             :      * NOTE:
   10719             :      * There are three criteria for stopping:
   10720             :      * (S0) maximum number of iterations
   10721             :      * (S1) ||Rk||<=EpsB*||B||;
   10722             :      * (S2) ||A^T*Rk||/(||A||*||Rk||)<=EpsA.
   10723             :      * It is very important that S2 always checked AFTER S1. It is necessary
   10724             :      * to avoid division by zero when Rk=0.
   10725             :      */
   10726           0 :     state->betai = bnorm;
   10727           0 :     if( ae_fp_eq(state->betai,(double)(0)) )
   10728             :     {
   10729             :         
   10730             :         /*
   10731             :          * Zero right part
   10732             :          */
   10733           0 :         state->running = ae_false;
   10734           0 :         state->repterminationtype = 1;
   10735           0 :         result = ae_false;
   10736           0 :         return result;
   10737             :     }
   10738           0 :     for(i=0; i<=summn-1; i++)
   10739             :     {
   10740           0 :         if( i<state->m )
   10741             :         {
   10742           0 :             state->ui.ptr.p_double[i] = state->b.ptr.p_double[i]/state->betai;
   10743             :         }
   10744             :         else
   10745             :         {
   10746           0 :             state->ui.ptr.p_double[i] = (double)(0);
   10747             :         }
   10748           0 :         state->x.ptr.p_double[i] = state->ui.ptr.p_double[i];
   10749             :     }
   10750           0 :     state->repnmv = state->repnmv+1;
   10751           0 :     linlsqr_clearrfields(state, _state);
   10752           0 :     state->needmtv = ae_true;
   10753           0 :     state->rstate.stage = 3;
   10754           0 :     goto lbl_rcomm;
   10755           0 : lbl_3:
   10756           0 :     state->needmtv = ae_false;
   10757           0 :     for(i=0; i<=state->n-1; i++)
   10758             :     {
   10759           0 :         state->mtv.ptr.p_double[i] = state->mtv.ptr.p_double[i]+state->lambdai*state->ui.ptr.p_double[state->m+i];
   10760             :     }
   10761           0 :     state->alphai = (double)(0);
   10762           0 :     for(i=0; i<=state->n-1; i++)
   10763             :     {
   10764           0 :         state->alphai = state->alphai+state->mtv.ptr.p_double[i]*state->mtv.ptr.p_double[i];
   10765             :     }
   10766           0 :     state->alphai = ae_sqrt(state->alphai, _state);
   10767           0 :     if( ae_fp_eq(state->alphai,(double)(0)) )
   10768             :     {
   10769             :         
   10770             :         /*
   10771             :          * Orthogonality stopping criterion is met
   10772             :          */
   10773           0 :         state->running = ae_false;
   10774           0 :         state->repterminationtype = 4;
   10775           0 :         result = ae_false;
   10776           0 :         return result;
   10777             :     }
   10778           0 :     for(i=0; i<=state->n-1; i++)
   10779             :     {
   10780           0 :         state->vi.ptr.p_double[i] = state->mtv.ptr.p_double[i]/state->alphai;
   10781           0 :         state->omegai.ptr.p_double[i] = state->vi.ptr.p_double[i];
   10782             :     }
   10783           0 :     state->phibari = state->betai;
   10784           0 :     state->rhobari = state->alphai;
   10785           0 :     for(i=0; i<=state->n-1; i++)
   10786             :     {
   10787           0 :         state->d.ptr.p_double[i] = (double)(0);
   10788             :     }
   10789           0 :     state->dnorm = (double)(0);
   10790             :     
   10791             :     /*
   10792             :      * Steps I=1, 2, ...
   10793             :      */
   10794           0 : lbl_15:
   10795             :     if( ae_false )
   10796             :     {
   10797             :         goto lbl_16;
   10798             :     }
   10799             :     
   10800             :     /*
   10801             :      * At I-th step State.RepIterationsCount=I.
   10802             :      */
   10803           0 :     state->repiterationscount = state->repiterationscount+1;
   10804             :     
   10805             :     /*
   10806             :      * Bidiagonalization part:
   10807             :      *     beta[i+1]*u[i+1]  = A_mod*v[i]-alpha[i]*u[i]
   10808             :      *     alpha[i+1]*v[i+1] = A_mod'*u[i+1] - beta[i+1]*v[i]
   10809             :      *     
   10810             :      * NOTE:  beta[i+1]=0 or alpha[i+1]=0 will lead to successful termination
   10811             :      *        in the end of the current iteration. In this case u/v are zero.
   10812             :      * NOTE2: algorithm won't fail on zero alpha or beta (there will be no
   10813             :      *        division by zero because it will be stopped BEFORE division
   10814             :      *        occurs). However, near-zero alpha and beta won't stop algorithm
   10815             :      *        and, although no division by zero will happen, orthogonality 
   10816             :      *        in U and V will be lost.
   10817             :      */
   10818           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->vi.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   10819           0 :     state->repnmv = state->repnmv+1;
   10820           0 :     linlsqr_clearrfields(state, _state);
   10821           0 :     state->needmv = ae_true;
   10822           0 :     state->rstate.stage = 4;
   10823           0 :     goto lbl_rcomm;
   10824           0 : lbl_4:
   10825           0 :     state->needmv = ae_false;
   10826           0 :     for(i=0; i<=state->n-1; i++)
   10827             :     {
   10828           0 :         state->mv.ptr.p_double[state->m+i] = state->lambdai*state->vi.ptr.p_double[i];
   10829             :     }
   10830           0 :     state->betaip1 = (double)(0);
   10831           0 :     for(i=0; i<=summn-1; i++)
   10832             :     {
   10833           0 :         state->uip1.ptr.p_double[i] = state->mv.ptr.p_double[i]-state->alphai*state->ui.ptr.p_double[i];
   10834           0 :         state->betaip1 = state->betaip1+state->uip1.ptr.p_double[i]*state->uip1.ptr.p_double[i];
   10835             :     }
   10836           0 :     if( ae_fp_neq(state->betaip1,(double)(0)) )
   10837             :     {
   10838           0 :         state->betaip1 = ae_sqrt(state->betaip1, _state);
   10839           0 :         for(i=0; i<=summn-1; i++)
   10840             :         {
   10841           0 :             state->uip1.ptr.p_double[i] = state->uip1.ptr.p_double[i]/state->betaip1;
   10842             :         }
   10843             :     }
   10844           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->uip1.ptr.p_double[0], 1, ae_v_len(0,state->m-1));
   10845           0 :     state->repnmv = state->repnmv+1;
   10846           0 :     linlsqr_clearrfields(state, _state);
   10847           0 :     state->needmtv = ae_true;
   10848           0 :     state->rstate.stage = 5;
   10849           0 :     goto lbl_rcomm;
   10850           0 : lbl_5:
   10851           0 :     state->needmtv = ae_false;
   10852           0 :     for(i=0; i<=state->n-1; i++)
   10853             :     {
   10854           0 :         state->mtv.ptr.p_double[i] = state->mtv.ptr.p_double[i]+state->lambdai*state->uip1.ptr.p_double[state->m+i];
   10855             :     }
   10856           0 :     state->alphaip1 = (double)(0);
   10857           0 :     for(i=0; i<=state->n-1; i++)
   10858             :     {
   10859           0 :         state->vip1.ptr.p_double[i] = state->mtv.ptr.p_double[i]-state->betaip1*state->vi.ptr.p_double[i];
   10860           0 :         state->alphaip1 = state->alphaip1+state->vip1.ptr.p_double[i]*state->vip1.ptr.p_double[i];
   10861             :     }
   10862           0 :     if( ae_fp_neq(state->alphaip1,(double)(0)) )
   10863             :     {
   10864           0 :         state->alphaip1 = ae_sqrt(state->alphaip1, _state);
   10865           0 :         for(i=0; i<=state->n-1; i++)
   10866             :         {
   10867           0 :             state->vip1.ptr.p_double[i] = state->vip1.ptr.p_double[i]/state->alphaip1;
   10868             :         }
   10869             :     }
   10870             :     
   10871             :     /*
   10872             :      * Build next orthogonal transformation
   10873             :      */
   10874           0 :     state->rhoi = safepythag2(state->rhobari, state->betaip1, _state);
   10875           0 :     state->ci = state->rhobari/state->rhoi;
   10876           0 :     state->si = state->betaip1/state->rhoi;
   10877           0 :     state->theta = state->si*state->alphaip1;
   10878           0 :     state->rhobarip1 = -state->ci*state->alphaip1;
   10879           0 :     state->phii = state->ci*state->phibari;
   10880           0 :     state->phibarip1 = state->si*state->phibari;
   10881             :     
   10882             :     /*
   10883             :      * Update .RNorm
   10884             :      *
   10885             :      * This tricky  formula  is  necessary  because  simply  writing
   10886             :      * State.R2:=State.PhiBarIP1*State.PhiBarIP1 does NOT guarantees
   10887             :      * monotonic decrease of R2. Roundoff error combined with 80-bit
   10888             :      * precision used internally by Intel chips allows R2 to increase
   10889             :      * slightly in some rare, but possible cases. This property is
   10890             :      * undesirable, so we prefer to guard against R increase.
   10891             :      */
   10892           0 :     state->r2 = ae_minreal(state->r2, state->phibarip1*state->phibarip1, _state);
   10893             :     
   10894             :     /*
   10895             :      * Update d and DNorm, check condition-related stopping criteria
   10896             :      */
   10897           0 :     for(i=0; i<=state->n-1; i++)
   10898             :     {
   10899           0 :         state->d.ptr.p_double[i] = 1/state->rhoi*(state->vi.ptr.p_double[i]-state->theta*state->d.ptr.p_double[i]);
   10900           0 :         state->dnorm = state->dnorm+state->d.ptr.p_double[i]*state->d.ptr.p_double[i];
   10901             :     }
   10902           0 :     if( ae_fp_greater_eq(ae_sqrt(state->dnorm, _state)*state->anorm,state->epsc) )
   10903             :     {
   10904           0 :         state->running = ae_false;
   10905           0 :         state->repterminationtype = 7;
   10906           0 :         result = ae_false;
   10907           0 :         return result;
   10908             :     }
   10909             :     
   10910             :     /*
   10911             :      * Update x, output report
   10912             :      */
   10913           0 :     for(i=0; i<=state->n-1; i++)
   10914             :     {
   10915           0 :         state->rx.ptr.p_double[i] = state->rx.ptr.p_double[i]+state->phii/state->rhoi*state->omegai.ptr.p_double[i];
   10916             :     }
   10917           0 :     if( !state->xrep )
   10918             :     {
   10919           0 :         goto lbl_17;
   10920             :     }
   10921           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   10922           0 :     linlsqr_clearrfields(state, _state);
   10923           0 :     state->xupdated = ae_true;
   10924           0 :     state->rstate.stage = 6;
   10925           0 :     goto lbl_rcomm;
   10926           0 : lbl_6:
   10927           0 :     state->xupdated = ae_false;
   10928           0 : lbl_17:
   10929             :     
   10930             :     /*
   10931             :      * Check stopping criteria
   10932             :      * 1. achieved required number of iterations;
   10933             :      * 2. ||Rk||<=EpsB*||B||;
   10934             :      * 3. ||A^T*Rk||/(||A||*||Rk||)<=EpsA;
   10935             :      */
   10936           0 :     if( state->maxits>0&&state->repiterationscount>=state->maxits )
   10937             :     {
   10938             :         
   10939             :         /*
   10940             :          * Achieved required number of iterations
   10941             :          */
   10942           0 :         state->running = ae_false;
   10943           0 :         state->repterminationtype = 5;
   10944           0 :         result = ae_false;
   10945           0 :         return result;
   10946             :     }
   10947           0 :     if( ae_fp_less_eq(state->phibarip1,state->epsb*bnorm) )
   10948             :     {
   10949             :         
   10950             :         /*
   10951             :          * ||Rk||<=EpsB*||B||, here ||Rk||=PhiBar
   10952             :          */
   10953           0 :         state->running = ae_false;
   10954           0 :         state->repterminationtype = 1;
   10955           0 :         result = ae_false;
   10956           0 :         return result;
   10957             :     }
   10958           0 :     if( ae_fp_less_eq(state->alphaip1*ae_fabs(state->ci, _state)/state->anorm,state->epsa) )
   10959             :     {
   10960             :         
   10961             :         /*
   10962             :          * ||A^T*Rk||/(||A||*||Rk||)<=EpsA, here ||A^T*Rk||=PhiBar*Alpha[i+1]*|.C|
   10963             :          */
   10964           0 :         state->running = ae_false;
   10965           0 :         state->repterminationtype = 4;
   10966           0 :         result = ae_false;
   10967           0 :         return result;
   10968             :     }
   10969           0 :     if( state->userterminationneeded )
   10970             :     {
   10971             :         
   10972             :         /*
   10973             :          * User requested termination
   10974             :          */
   10975           0 :         state->running = ae_false;
   10976           0 :         state->repterminationtype = 8;
   10977           0 :         result = ae_false;
   10978           0 :         return result;
   10979             :     }
   10980             :     
   10981             :     /*
   10982             :      * Update omega
   10983             :      */
   10984           0 :     for(i=0; i<=state->n-1; i++)
   10985             :     {
   10986           0 :         state->omegaip1.ptr.p_double[i] = state->vip1.ptr.p_double[i]-state->theta/state->rhoi*state->omegai.ptr.p_double[i];
   10987             :     }
   10988             :     
   10989             :     /*
   10990             :      * Prepare for the next iteration - rename variables:
   10991             :      * u[i]   := u[i+1]
   10992             :      * v[i]   := v[i+1]
   10993             :      * rho[i] := rho[i+1]
   10994             :      * ...
   10995             :      */
   10996           0 :     ae_v_move(&state->ui.ptr.p_double[0], 1, &state->uip1.ptr.p_double[0], 1, ae_v_len(0,summn-1));
   10997           0 :     ae_v_move(&state->vi.ptr.p_double[0], 1, &state->vip1.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   10998           0 :     ae_v_move(&state->omegai.ptr.p_double[0], 1, &state->omegaip1.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   10999           0 :     state->alphai = state->alphaip1;
   11000           0 :     state->betai = state->betaip1;
   11001           0 :     state->phibari = state->phibarip1;
   11002           0 :     state->rhobari = state->rhobarip1;
   11003           0 :     goto lbl_15;
   11004             : lbl_16:
   11005             :     result = ae_false;
   11006             :     return result;
   11007             :     
   11008             :     /*
   11009             :      * Saving state
   11010             :      */
   11011           0 : lbl_rcomm:
   11012           0 :     result = ae_true;
   11013           0 :     state->rstate.ia.ptr.p_int[0] = summn;
   11014           0 :     state->rstate.ia.ptr.p_int[1] = i;
   11015           0 :     state->rstate.ra.ptr.p_double[0] = bnorm;
   11016           0 :     return result;
   11017             : }
   11018             : 
   11019             : 
   11020             : /*************************************************************************
   11021             : Procedure for solution of A*x=b with sparse A.
   11022             : 
   11023             : INPUT PARAMETERS:
   11024             :     State   -   algorithm state
   11025             :     A       -   sparse M*N matrix in the CRS format (you MUST contvert  it 
   11026             :                 to CRS format  by  calling  SparseConvertToCRS()  function
   11027             :                 BEFORE you pass it to this function).
   11028             :     B       -   right part, array[M]
   11029             : 
   11030             : RESULT:
   11031             :     This function returns no result.
   11032             :     You can get solution by calling LinCGResults()
   11033             :     
   11034             : NOTE: this function uses lightweight preconditioning -  multiplication  by
   11035             :       inverse of diag(A). If you want, you can turn preconditioning off by
   11036             :       calling LinLSQRSetPrecUnit(). However, preconditioning cost is   low
   11037             :       and preconditioner is very important for solution  of  badly  scaled
   11038             :       problems.
   11039             : 
   11040             :   -- ALGLIB --
   11041             :      Copyright 30.11.2011 by Bochkanov Sergey
   11042             : *************************************************************************/
   11043           0 : void linlsqrsolvesparse(linlsqrstate* state,
   11044             :      sparsematrix* a,
   11045             :      /* Real    */ ae_vector* b,
   11046             :      ae_state *_state)
   11047             : {
   11048             :     ae_int_t n;
   11049             :     ae_int_t i;
   11050             :     ae_int_t j;
   11051             :     ae_int_t t0;
   11052             :     ae_int_t t1;
   11053             :     double v;
   11054             : 
   11055             : 
   11056           0 :     n = state->n;
   11057           0 :     ae_assert(!state->running, "LinLSQRSolveSparse: you can not call this function when LinLSQRIteration is running", _state);
   11058           0 :     ae_assert(b->cnt>=state->m, "LinLSQRSolveSparse: Length(B)<M", _state);
   11059           0 :     ae_assert(isfinitevector(b, state->m, _state), "LinLSQRSolveSparse: B contains infinite or NaN values", _state);
   11060             :     
   11061             :     /*
   11062             :      * Allocate temporaries
   11063             :      */
   11064           0 :     rvectorsetlengthatleast(&state->tmpd, n, _state);
   11065           0 :     rvectorsetlengthatleast(&state->tmpx, n, _state);
   11066             :     
   11067             :     /*
   11068             :      * Compute diagonal scaling matrix D
   11069             :      */
   11070           0 :     if( state->prectype==0 )
   11071             :     {
   11072             :         
   11073             :         /*
   11074             :          * Default preconditioner - inverse of column norms
   11075             :          */
   11076           0 :         for(i=0; i<=n-1; i++)
   11077             :         {
   11078           0 :             state->tmpd.ptr.p_double[i] = (double)(0);
   11079             :         }
   11080           0 :         t0 = 0;
   11081           0 :         t1 = 0;
   11082           0 :         while(sparseenumerate(a, &t0, &t1, &i, &j, &v, _state))
   11083             :         {
   11084           0 :             state->tmpd.ptr.p_double[j] = state->tmpd.ptr.p_double[j]+ae_sqr(v, _state);
   11085             :         }
   11086           0 :         for(i=0; i<=n-1; i++)
   11087             :         {
   11088           0 :             if( ae_fp_greater(state->tmpd.ptr.p_double[i],(double)(0)) )
   11089             :             {
   11090           0 :                 state->tmpd.ptr.p_double[i] = 1/ae_sqrt(state->tmpd.ptr.p_double[i], _state);
   11091             :             }
   11092             :             else
   11093             :             {
   11094           0 :                 state->tmpd.ptr.p_double[i] = (double)(1);
   11095             :             }
   11096             :         }
   11097             :     }
   11098             :     else
   11099             :     {
   11100             :         
   11101             :         /*
   11102             :          * No diagonal scaling
   11103             :          */
   11104           0 :         for(i=0; i<=n-1; i++)
   11105             :         {
   11106           0 :             state->tmpd.ptr.p_double[i] = (double)(1);
   11107             :         }
   11108             :     }
   11109             :     
   11110             :     /*
   11111             :      * Solve.
   11112             :      *
   11113             :      * Instead of solving A*x=b we solve preconditioned system (A*D)*(inv(D)*x)=b.
   11114             :      * Transformed A is not calculated explicitly, we just modify multiplication
   11115             :      * by A or A'. After solution we modify State.RX so it will store untransformed
   11116             :      * variables
   11117             :      */
   11118           0 :     linlsqrsetb(state, b, _state);
   11119           0 :     linlsqrrestart(state, _state);
   11120           0 :     while(linlsqriteration(state, _state))
   11121             :     {
   11122           0 :         if( state->needmv )
   11123             :         {
   11124           0 :             for(i=0; i<=n-1; i++)
   11125             :             {
   11126           0 :                 state->tmpx.ptr.p_double[i] = state->tmpd.ptr.p_double[i]*state->x.ptr.p_double[i];
   11127             :             }
   11128           0 :             sparsemv(a, &state->tmpx, &state->mv, _state);
   11129             :         }
   11130           0 :         if( state->needmtv )
   11131             :         {
   11132           0 :             sparsemtv(a, &state->x, &state->mtv, _state);
   11133           0 :             for(i=0; i<=n-1; i++)
   11134             :             {
   11135           0 :                 state->mtv.ptr.p_double[i] = state->tmpd.ptr.p_double[i]*state->mtv.ptr.p_double[i];
   11136             :             }
   11137             :         }
   11138             :     }
   11139           0 :     for(i=0; i<=n-1; i++)
   11140             :     {
   11141           0 :         state->rx.ptr.p_double[i] = state->tmpd.ptr.p_double[i]*state->rx.ptr.p_double[i];
   11142             :     }
   11143           0 : }
   11144             : 
   11145             : 
   11146             : /*************************************************************************
   11147             : This function sets stopping criteria.
   11148             : 
   11149             : INPUT PARAMETERS:
   11150             :     EpsA    -   algorithm will be stopped if ||A^T*Rk||/(||A||*||Rk||)<=EpsA.
   11151             :     EpsB    -   algorithm will be stopped if ||Rk||<=EpsB*||B||
   11152             :     MaxIts  -   algorithm will be stopped if number of iterations
   11153             :                 more than MaxIts.
   11154             : 
   11155             : OUTPUT PARAMETERS:
   11156             :     State   -   structure which stores algorithm state
   11157             : 
   11158             : NOTE: if EpsA,EpsB,EpsC and MaxIts are zero then these variables will
   11159             : be setted as default values.
   11160             :     
   11161             :   -- ALGLIB --
   11162             :      Copyright 30.11.2011 by Bochkanov Sergey
   11163             : *************************************************************************/
   11164           0 : void linlsqrsetcond(linlsqrstate* state,
   11165             :      double epsa,
   11166             :      double epsb,
   11167             :      ae_int_t maxits,
   11168             :      ae_state *_state)
   11169             : {
   11170             : 
   11171             : 
   11172           0 :     ae_assert(!state->running, "LinLSQRSetCond: you can not call this function when LinLSQRIteration is running", _state);
   11173           0 :     ae_assert(ae_isfinite(epsa, _state)&&ae_fp_greater_eq(epsa,(double)(0)), "LinLSQRSetCond: EpsA is negative, INF or NAN", _state);
   11174           0 :     ae_assert(ae_isfinite(epsb, _state)&&ae_fp_greater_eq(epsb,(double)(0)), "LinLSQRSetCond: EpsB is negative, INF or NAN", _state);
   11175           0 :     ae_assert(maxits>=0, "LinLSQRSetCond: MaxIts is negative", _state);
   11176           0 :     if( (ae_fp_eq(epsa,(double)(0))&&ae_fp_eq(epsb,(double)(0)))&&maxits==0 )
   11177             :     {
   11178           0 :         state->epsa = linlsqr_atol;
   11179           0 :         state->epsb = linlsqr_btol;
   11180           0 :         state->maxits = state->n;
   11181             :     }
   11182             :     else
   11183             :     {
   11184           0 :         state->epsa = epsa;
   11185           0 :         state->epsb = epsb;
   11186           0 :         state->maxits = maxits;
   11187             :     }
   11188           0 : }
   11189             : 
   11190             : 
   11191             : /*************************************************************************
   11192             : LSQR solver: results.
   11193             : 
   11194             : This function must be called after LinLSQRSolve
   11195             : 
   11196             : INPUT PARAMETERS:
   11197             :     State   -   algorithm state
   11198             : 
   11199             : OUTPUT PARAMETERS:
   11200             :     X       -   array[N], solution
   11201             :     Rep     -   optimization report:
   11202             :                 * Rep.TerminationType completetion code:
   11203             :                     *  1    ||Rk||<=EpsB*||B||
   11204             :                     *  4    ||A^T*Rk||/(||A||*||Rk||)<=EpsA
   11205             :                     *  5    MaxIts steps was taken
   11206             :                     *  7    rounding errors prevent further progress,
   11207             :                             X contains best point found so far.
   11208             :                             (sometimes returned on singular systems)
   11209             :                     *  8    user requested termination via calling
   11210             :                             linlsqrrequesttermination()
   11211             :                 * Rep.IterationsCount contains iterations count
   11212             :                 * NMV countains number of matrix-vector calculations
   11213             :                 
   11214             :   -- ALGLIB --
   11215             :      Copyright 30.11.2011 by Bochkanov Sergey
   11216             : *************************************************************************/
   11217           0 : void linlsqrresults(linlsqrstate* state,
   11218             :      /* Real    */ ae_vector* x,
   11219             :      linlsqrreport* rep,
   11220             :      ae_state *_state)
   11221             : {
   11222             : 
   11223           0 :     ae_vector_clear(x);
   11224           0 :     _linlsqrreport_clear(rep);
   11225             : 
   11226           0 :     ae_assert(!state->running, "LinLSQRResult: you can not call this function when LinLSQRIteration is running", _state);
   11227           0 :     if( x->cnt<state->n )
   11228             :     {
   11229           0 :         ae_vector_set_length(x, state->n, _state);
   11230             :     }
   11231           0 :     ae_v_move(&x->ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   11232           0 :     rep->iterationscount = state->repiterationscount;
   11233           0 :     rep->nmv = state->repnmv;
   11234           0 :     rep->terminationtype = state->repterminationtype;
   11235           0 : }
   11236             : 
   11237             : 
   11238             : /*************************************************************************
   11239             : This function turns on/off reporting.
   11240             : 
   11241             : INPUT PARAMETERS:
   11242             :     State   -   structure which stores algorithm state
   11243             :     NeedXRep-   whether iteration reports are needed or not
   11244             : 
   11245             : If NeedXRep is True, algorithm will call rep() callback function if  it is
   11246             : provided to MinCGOptimize().
   11247             : 
   11248             :   -- ALGLIB --
   11249             :      Copyright 30.11.2011 by Bochkanov Sergey
   11250             : *************************************************************************/
   11251           0 : void linlsqrsetxrep(linlsqrstate* state,
   11252             :      ae_bool needxrep,
   11253             :      ae_state *_state)
   11254             : {
   11255             : 
   11256             : 
   11257           0 :     state->xrep = needxrep;
   11258           0 : }
   11259             : 
   11260             : 
   11261             : /*************************************************************************
   11262             : This function restarts LinLSQRIteration
   11263             : 
   11264             :   -- ALGLIB --
   11265             :      Copyright 30.11.2011 by Bochkanov Sergey
   11266             : *************************************************************************/
   11267           0 : void linlsqrrestart(linlsqrstate* state, ae_state *_state)
   11268             : {
   11269             : 
   11270             : 
   11271           0 :     ae_vector_set_length(&state->rstate.ia, 1+1, _state);
   11272           0 :     ae_vector_set_length(&state->rstate.ra, 0+1, _state);
   11273           0 :     state->rstate.stage = -1;
   11274           0 :     linlsqr_clearrfields(state, _state);
   11275           0 :     state->repiterationscount = 0;
   11276           0 : }
   11277             : 
   11278             : 
   11279             : /*************************************************************************
   11280             : This function is used to peek into LSQR solver and get  current  iteration
   11281             : counter. You can safely "peek" into the solver from another thread.
   11282             : 
   11283             : INPUT PARAMETERS:
   11284             :     S           -   solver object
   11285             : 
   11286             : RESULT:
   11287             :     iteration counter, in [0,INF)
   11288             : 
   11289             :   -- ALGLIB --
   11290             :      Copyright 21.05.2018 by Bochkanov Sergey
   11291             : *************************************************************************/
   11292           0 : ae_int_t linlsqrpeekiterationscount(linlsqrstate* s, ae_state *_state)
   11293             : {
   11294             :     ae_int_t result;
   11295             : 
   11296             : 
   11297           0 :     result = s->repiterationscount;
   11298           0 :     return result;
   11299             : }
   11300             : 
   11301             : 
   11302             : /*************************************************************************
   11303             : This subroutine submits request for termination of the running solver.  It
   11304             : can be called from some other thread which wants LSQR solver to  terminate
   11305             : (obviously, the  thread  running  LSQR  solver can not request termination
   11306             : because it is already busy working on LSQR).
   11307             : 
   11308             : As result, solver  stops  at  point  which  was  "current  accepted"  when
   11309             : termination  request  was  submitted  and returns error code 8 (successful
   11310             : termination).  Such   termination   is  a smooth  process  which  properly
   11311             : deallocates all temporaries.
   11312             : 
   11313             : INPUT PARAMETERS:
   11314             :     State   -   solver structure
   11315             : 
   11316             : NOTE: calling this function on solver which is NOT running  will  have  no
   11317             :       effect.
   11318             :       
   11319             : NOTE: multiple calls to this function are possible. First call is counted,
   11320             :       subsequent calls are silently ignored.
   11321             : 
   11322             : NOTE: solver clears termination flag on its start, it means that  if  some
   11323             :       other thread will request termination too soon, its request will went
   11324             :       unnoticed.
   11325             : 
   11326             :   -- ALGLIB --
   11327             :      Copyright 08.10.2014 by Bochkanov Sergey
   11328             : *************************************************************************/
   11329           0 : void linlsqrrequesttermination(linlsqrstate* state, ae_state *_state)
   11330             : {
   11331             : 
   11332             : 
   11333           0 :     state->userterminationneeded = ae_true;
   11334           0 : }
   11335             : 
   11336             : 
   11337             : /*************************************************************************
   11338             : Clears request fileds (to be sure that we don't forgot to clear something)
   11339             : *************************************************************************/
   11340           0 : static void linlsqr_clearrfields(linlsqrstate* state, ae_state *_state)
   11341             : {
   11342             : 
   11343             : 
   11344           0 :     state->xupdated = ae_false;
   11345           0 :     state->needmv = ae_false;
   11346           0 :     state->needmtv = ae_false;
   11347           0 :     state->needmv2 = ae_false;
   11348           0 :     state->needvmv = ae_false;
   11349           0 :     state->needprec = ae_false;
   11350           0 : }
   11351             : 
   11352             : 
   11353           0 : void _linlsqrstate_init(void* _p, ae_state *_state, ae_bool make_automatic)
   11354             : {
   11355           0 :     linlsqrstate *p = (linlsqrstate*)_p;
   11356           0 :     ae_touch_ptr((void*)p);
   11357           0 :     _normestimatorstate_init(&p->nes, _state, make_automatic);
   11358           0 :     ae_vector_init(&p->rx, 0, DT_REAL, _state, make_automatic);
   11359           0 :     ae_vector_init(&p->b, 0, DT_REAL, _state, make_automatic);
   11360           0 :     ae_vector_init(&p->ui, 0, DT_REAL, _state, make_automatic);
   11361           0 :     ae_vector_init(&p->uip1, 0, DT_REAL, _state, make_automatic);
   11362           0 :     ae_vector_init(&p->vi, 0, DT_REAL, _state, make_automatic);
   11363           0 :     ae_vector_init(&p->vip1, 0, DT_REAL, _state, make_automatic);
   11364           0 :     ae_vector_init(&p->omegai, 0, DT_REAL, _state, make_automatic);
   11365           0 :     ae_vector_init(&p->omegaip1, 0, DT_REAL, _state, make_automatic);
   11366           0 :     ae_vector_init(&p->d, 0, DT_REAL, _state, make_automatic);
   11367           0 :     ae_vector_init(&p->x, 0, DT_REAL, _state, make_automatic);
   11368           0 :     ae_vector_init(&p->mv, 0, DT_REAL, _state, make_automatic);
   11369           0 :     ae_vector_init(&p->mtv, 0, DT_REAL, _state, make_automatic);
   11370           0 :     ae_vector_init(&p->tmpd, 0, DT_REAL, _state, make_automatic);
   11371           0 :     ae_vector_init(&p->tmpx, 0, DT_REAL, _state, make_automatic);
   11372           0 :     _rcommstate_init(&p->rstate, _state, make_automatic);
   11373           0 : }
   11374             : 
   11375             : 
   11376           0 : void _linlsqrstate_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   11377             : {
   11378           0 :     linlsqrstate *dst = (linlsqrstate*)_dst;
   11379           0 :     linlsqrstate *src = (linlsqrstate*)_src;
   11380           0 :     _normestimatorstate_init_copy(&dst->nes, &src->nes, _state, make_automatic);
   11381           0 :     ae_vector_init_copy(&dst->rx, &src->rx, _state, make_automatic);
   11382           0 :     ae_vector_init_copy(&dst->b, &src->b, _state, make_automatic);
   11383           0 :     dst->n = src->n;
   11384           0 :     dst->m = src->m;
   11385           0 :     dst->prectype = src->prectype;
   11386           0 :     ae_vector_init_copy(&dst->ui, &src->ui, _state, make_automatic);
   11387           0 :     ae_vector_init_copy(&dst->uip1, &src->uip1, _state, make_automatic);
   11388           0 :     ae_vector_init_copy(&dst->vi, &src->vi, _state, make_automatic);
   11389           0 :     ae_vector_init_copy(&dst->vip1, &src->vip1, _state, make_automatic);
   11390           0 :     ae_vector_init_copy(&dst->omegai, &src->omegai, _state, make_automatic);
   11391           0 :     ae_vector_init_copy(&dst->omegaip1, &src->omegaip1, _state, make_automatic);
   11392           0 :     dst->alphai = src->alphai;
   11393           0 :     dst->alphaip1 = src->alphaip1;
   11394           0 :     dst->betai = src->betai;
   11395           0 :     dst->betaip1 = src->betaip1;
   11396           0 :     dst->phibari = src->phibari;
   11397           0 :     dst->phibarip1 = src->phibarip1;
   11398           0 :     dst->phii = src->phii;
   11399           0 :     dst->rhobari = src->rhobari;
   11400           0 :     dst->rhobarip1 = src->rhobarip1;
   11401           0 :     dst->rhoi = src->rhoi;
   11402           0 :     dst->ci = src->ci;
   11403           0 :     dst->si = src->si;
   11404           0 :     dst->theta = src->theta;
   11405           0 :     dst->lambdai = src->lambdai;
   11406           0 :     ae_vector_init_copy(&dst->d, &src->d, _state, make_automatic);
   11407           0 :     dst->anorm = src->anorm;
   11408           0 :     dst->bnorm2 = src->bnorm2;
   11409           0 :     dst->dnorm = src->dnorm;
   11410           0 :     dst->r2 = src->r2;
   11411           0 :     ae_vector_init_copy(&dst->x, &src->x, _state, make_automatic);
   11412           0 :     ae_vector_init_copy(&dst->mv, &src->mv, _state, make_automatic);
   11413           0 :     ae_vector_init_copy(&dst->mtv, &src->mtv, _state, make_automatic);
   11414           0 :     dst->epsa = src->epsa;
   11415           0 :     dst->epsb = src->epsb;
   11416           0 :     dst->epsc = src->epsc;
   11417           0 :     dst->maxits = src->maxits;
   11418           0 :     dst->xrep = src->xrep;
   11419           0 :     dst->xupdated = src->xupdated;
   11420           0 :     dst->needmv = src->needmv;
   11421           0 :     dst->needmtv = src->needmtv;
   11422           0 :     dst->needmv2 = src->needmv2;
   11423           0 :     dst->needvmv = src->needvmv;
   11424           0 :     dst->needprec = src->needprec;
   11425           0 :     dst->repiterationscount = src->repiterationscount;
   11426           0 :     dst->repnmv = src->repnmv;
   11427           0 :     dst->repterminationtype = src->repterminationtype;
   11428           0 :     dst->running = src->running;
   11429           0 :     dst->userterminationneeded = src->userterminationneeded;
   11430           0 :     ae_vector_init_copy(&dst->tmpd, &src->tmpd, _state, make_automatic);
   11431           0 :     ae_vector_init_copy(&dst->tmpx, &src->tmpx, _state, make_automatic);
   11432           0 :     _rcommstate_init_copy(&dst->rstate, &src->rstate, _state, make_automatic);
   11433           0 : }
   11434             : 
   11435             : 
   11436           0 : void _linlsqrstate_clear(void* _p)
   11437             : {
   11438           0 :     linlsqrstate *p = (linlsqrstate*)_p;
   11439           0 :     ae_touch_ptr((void*)p);
   11440           0 :     _normestimatorstate_clear(&p->nes);
   11441           0 :     ae_vector_clear(&p->rx);
   11442           0 :     ae_vector_clear(&p->b);
   11443           0 :     ae_vector_clear(&p->ui);
   11444           0 :     ae_vector_clear(&p->uip1);
   11445           0 :     ae_vector_clear(&p->vi);
   11446           0 :     ae_vector_clear(&p->vip1);
   11447           0 :     ae_vector_clear(&p->omegai);
   11448           0 :     ae_vector_clear(&p->omegaip1);
   11449           0 :     ae_vector_clear(&p->d);
   11450           0 :     ae_vector_clear(&p->x);
   11451           0 :     ae_vector_clear(&p->mv);
   11452           0 :     ae_vector_clear(&p->mtv);
   11453           0 :     ae_vector_clear(&p->tmpd);
   11454           0 :     ae_vector_clear(&p->tmpx);
   11455           0 :     _rcommstate_clear(&p->rstate);
   11456           0 : }
   11457             : 
   11458             : 
   11459           0 : void _linlsqrstate_destroy(void* _p)
   11460             : {
   11461           0 :     linlsqrstate *p = (linlsqrstate*)_p;
   11462           0 :     ae_touch_ptr((void*)p);
   11463           0 :     _normestimatorstate_destroy(&p->nes);
   11464           0 :     ae_vector_destroy(&p->rx);
   11465           0 :     ae_vector_destroy(&p->b);
   11466           0 :     ae_vector_destroy(&p->ui);
   11467           0 :     ae_vector_destroy(&p->uip1);
   11468           0 :     ae_vector_destroy(&p->vi);
   11469           0 :     ae_vector_destroy(&p->vip1);
   11470           0 :     ae_vector_destroy(&p->omegai);
   11471           0 :     ae_vector_destroy(&p->omegaip1);
   11472           0 :     ae_vector_destroy(&p->d);
   11473           0 :     ae_vector_destroy(&p->x);
   11474           0 :     ae_vector_destroy(&p->mv);
   11475           0 :     ae_vector_destroy(&p->mtv);
   11476           0 :     ae_vector_destroy(&p->tmpd);
   11477           0 :     ae_vector_destroy(&p->tmpx);
   11478           0 :     _rcommstate_destroy(&p->rstate);
   11479           0 : }
   11480             : 
   11481             : 
   11482           0 : void _linlsqrreport_init(void* _p, ae_state *_state, ae_bool make_automatic)
   11483             : {
   11484           0 :     linlsqrreport *p = (linlsqrreport*)_p;
   11485           0 :     ae_touch_ptr((void*)p);
   11486           0 : }
   11487             : 
   11488             : 
   11489           0 : void _linlsqrreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   11490             : {
   11491           0 :     linlsqrreport *dst = (linlsqrreport*)_dst;
   11492           0 :     linlsqrreport *src = (linlsqrreport*)_src;
   11493           0 :     dst->iterationscount = src->iterationscount;
   11494           0 :     dst->nmv = src->nmv;
   11495           0 :     dst->terminationtype = src->terminationtype;
   11496           0 : }
   11497             : 
   11498             : 
   11499           0 : void _linlsqrreport_clear(void* _p)
   11500             : {
   11501           0 :     linlsqrreport *p = (linlsqrreport*)_p;
   11502           0 :     ae_touch_ptr((void*)p);
   11503           0 : }
   11504             : 
   11505             : 
   11506           0 : void _linlsqrreport_destroy(void* _p)
   11507             : {
   11508           0 :     linlsqrreport *p = (linlsqrreport*)_p;
   11509           0 :     ae_touch_ptr((void*)p);
   11510           0 : }
   11511             : 
   11512             : 
   11513             : #endif
   11514             : #if defined(AE_COMPILE_POLYNOMIALSOLVER) || !defined(AE_PARTIAL_BUILD)
   11515             : 
   11516             : 
   11517             : /*************************************************************************
   11518             : Polynomial root finding.
   11519             : 
   11520             : This function returns all roots of the polynomial
   11521             :     P(x) = a0 + a1*x + a2*x^2 + ... + an*x^n
   11522             : Both real and complex roots are returned (see below).
   11523             : 
   11524             : INPUT PARAMETERS:
   11525             :     A       -   array[N+1], polynomial coefficients:
   11526             :                 * A[0] is constant term
   11527             :                 * A[N] is a coefficient of X^N
   11528             :     N       -   polynomial degree
   11529             : 
   11530             : OUTPUT PARAMETERS:
   11531             :     X       -   array of complex roots:
   11532             :                 * for isolated real root, X[I] is strictly real: IMAGE(X[I])=0
   11533             :                 * complex roots are always returned in pairs - roots occupy
   11534             :                   positions I and I+1, with:
   11535             :                   * X[I+1]=Conj(X[I])
   11536             :                   * IMAGE(X[I]) > 0
   11537             :                   * IMAGE(X[I+1]) = -IMAGE(X[I]) < 0
   11538             :                 * multiple real roots may have non-zero imaginary part due
   11539             :                   to roundoff errors. There is no reliable way to distinguish
   11540             :                   real root of multiplicity 2 from two  complex  roots  in
   11541             :                   the presence of roundoff errors.
   11542             :     Rep     -   report, additional information, following fields are set:
   11543             :                 * Rep.MaxErr - max( |P(xi)| )  for  i=0..N-1.  This  field
   11544             :                   allows to quickly estimate "quality" of the roots  being
   11545             :                   returned.
   11546             : 
   11547             : NOTE:   this function uses companion matrix method to find roots. In  case
   11548             :         internal EVD  solver  fails  do  find  eigenvalues,  exception  is
   11549             :         generated.
   11550             : 
   11551             : NOTE:   roots are not "polished" and  no  matrix  balancing  is  performed
   11552             :         for them.
   11553             : 
   11554             :   -- ALGLIB --
   11555             :      Copyright 24.02.2014 by Bochkanov Sergey
   11556             : *************************************************************************/
   11557           0 : void polynomialsolve(/* Real    */ ae_vector* a,
   11558             :      ae_int_t n,
   11559             :      /* Complex */ ae_vector* x,
   11560             :      polynomialsolverreport* rep,
   11561             :      ae_state *_state)
   11562             : {
   11563             :     ae_frame _frame_block;
   11564             :     ae_vector _a;
   11565             :     ae_matrix c;
   11566             :     ae_matrix vl;
   11567             :     ae_matrix vr;
   11568             :     ae_vector wr;
   11569             :     ae_vector wi;
   11570             :     ae_int_t i;
   11571             :     ae_int_t j;
   11572             :     ae_bool status;
   11573             :     ae_int_t nz;
   11574             :     ae_int_t ne;
   11575             :     ae_complex v;
   11576             :     ae_complex vv;
   11577             : 
   11578           0 :     ae_frame_make(_state, &_frame_block);
   11579           0 :     memset(&_a, 0, sizeof(_a));
   11580           0 :     memset(&c, 0, sizeof(c));
   11581           0 :     memset(&vl, 0, sizeof(vl));
   11582           0 :     memset(&vr, 0, sizeof(vr));
   11583           0 :     memset(&wr, 0, sizeof(wr));
   11584           0 :     memset(&wi, 0, sizeof(wi));
   11585           0 :     ae_vector_init_copy(&_a, a, _state, ae_true);
   11586           0 :     a = &_a;
   11587           0 :     ae_vector_clear(x);
   11588           0 :     _polynomialsolverreport_clear(rep);
   11589           0 :     ae_matrix_init(&c, 0, 0, DT_REAL, _state, ae_true);
   11590           0 :     ae_matrix_init(&vl, 0, 0, DT_REAL, _state, ae_true);
   11591           0 :     ae_matrix_init(&vr, 0, 0, DT_REAL, _state, ae_true);
   11592           0 :     ae_vector_init(&wr, 0, DT_REAL, _state, ae_true);
   11593           0 :     ae_vector_init(&wi, 0, DT_REAL, _state, ae_true);
   11594             : 
   11595           0 :     ae_assert(n>0, "PolynomialSolve: N<=0", _state);
   11596           0 :     ae_assert(a->cnt>=n+1, "PolynomialSolve: Length(A)<N+1", _state);
   11597           0 :     ae_assert(isfinitevector(a, n+1, _state), "PolynomialSolve: A contains infitite numbers", _state);
   11598           0 :     ae_assert(ae_fp_neq(a->ptr.p_double[n],(double)(0)), "PolynomialSolve: A[N]=0", _state);
   11599             :     
   11600             :     /*
   11601             :      * Prepare
   11602             :      */
   11603           0 :     ae_vector_set_length(x, n, _state);
   11604             :     
   11605             :     /*
   11606             :      * Normalize A:
   11607             :      * * analytically determine NZ zero roots
   11608             :      * * quick exit for NZ=N
   11609             :      * * make residual NE-th degree polynomial monic
   11610             :      *   (here NE=N-NZ)
   11611             :      */
   11612           0 :     nz = 0;
   11613           0 :     while(nz<n&&ae_fp_eq(a->ptr.p_double[nz],(double)(0)))
   11614             :     {
   11615           0 :         nz = nz+1;
   11616             :     }
   11617           0 :     ne = n-nz;
   11618           0 :     for(i=nz; i<=n; i++)
   11619             :     {
   11620           0 :         a->ptr.p_double[i-nz] = a->ptr.p_double[i]/a->ptr.p_double[n];
   11621             :     }
   11622             :     
   11623             :     /*
   11624             :      * For NZ<N, build companion matrix and find NE non-zero roots
   11625             :      */
   11626           0 :     if( ne>0 )
   11627             :     {
   11628           0 :         ae_matrix_set_length(&c, ne, ne, _state);
   11629           0 :         for(i=0; i<=ne-1; i++)
   11630             :         {
   11631           0 :             for(j=0; j<=ne-1; j++)
   11632             :             {
   11633           0 :                 c.ptr.pp_double[i][j] = (double)(0);
   11634             :             }
   11635             :         }
   11636           0 :         c.ptr.pp_double[0][ne-1] = -a->ptr.p_double[0];
   11637           0 :         for(i=1; i<=ne-1; i++)
   11638             :         {
   11639           0 :             c.ptr.pp_double[i][i-1] = (double)(1);
   11640           0 :             c.ptr.pp_double[i][ne-1] = -a->ptr.p_double[i];
   11641             :         }
   11642           0 :         status = rmatrixevd(&c, ne, 0, &wr, &wi, &vl, &vr, _state);
   11643           0 :         ae_assert(status, "PolynomialSolve: inernal error - EVD solver failed", _state);
   11644           0 :         for(i=0; i<=ne-1; i++)
   11645             :         {
   11646           0 :             x->ptr.p_complex[i].x = wr.ptr.p_double[i];
   11647           0 :             x->ptr.p_complex[i].y = wi.ptr.p_double[i];
   11648             :         }
   11649             :     }
   11650             :     
   11651             :     /*
   11652             :      * Remaining NZ zero roots
   11653             :      */
   11654           0 :     for(i=ne; i<=n-1; i++)
   11655             :     {
   11656           0 :         x->ptr.p_complex[i] = ae_complex_from_i(0);
   11657             :     }
   11658             :     
   11659             :     /*
   11660             :      * Rep
   11661             :      */
   11662           0 :     rep->maxerr = (double)(0);
   11663           0 :     for(i=0; i<=ne-1; i++)
   11664             :     {
   11665           0 :         v = ae_complex_from_i(0);
   11666           0 :         vv = ae_complex_from_i(1);
   11667           0 :         for(j=0; j<=ne; j++)
   11668             :         {
   11669           0 :             v = ae_c_add(v,ae_c_mul_d(vv,a->ptr.p_double[j]));
   11670           0 :             vv = ae_c_mul(vv,x->ptr.p_complex[i]);
   11671             :         }
   11672           0 :         rep->maxerr = ae_maxreal(rep->maxerr, ae_c_abs(v, _state), _state);
   11673             :     }
   11674           0 :     ae_frame_leave(_state);
   11675           0 : }
   11676             : 
   11677             : 
   11678           0 : void _polynomialsolverreport_init(void* _p, ae_state *_state, ae_bool make_automatic)
   11679             : {
   11680           0 :     polynomialsolverreport *p = (polynomialsolverreport*)_p;
   11681           0 :     ae_touch_ptr((void*)p);
   11682           0 : }
   11683             : 
   11684             : 
   11685           0 : void _polynomialsolverreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   11686             : {
   11687           0 :     polynomialsolverreport *dst = (polynomialsolverreport*)_dst;
   11688           0 :     polynomialsolverreport *src = (polynomialsolverreport*)_src;
   11689           0 :     dst->maxerr = src->maxerr;
   11690           0 : }
   11691             : 
   11692             : 
   11693           0 : void _polynomialsolverreport_clear(void* _p)
   11694             : {
   11695           0 :     polynomialsolverreport *p = (polynomialsolverreport*)_p;
   11696           0 :     ae_touch_ptr((void*)p);
   11697           0 : }
   11698             : 
   11699             : 
   11700           0 : void _polynomialsolverreport_destroy(void* _p)
   11701             : {
   11702           0 :     polynomialsolverreport *p = (polynomialsolverreport*)_p;
   11703           0 :     ae_touch_ptr((void*)p);
   11704           0 : }
   11705             : 
   11706             : 
   11707             : #endif
   11708             : #if defined(AE_COMPILE_NLEQ) || !defined(AE_PARTIAL_BUILD)
   11709             : 
   11710             : 
   11711             : /*************************************************************************
   11712             :                 LEVENBERG-MARQUARDT-LIKE NONLINEAR SOLVER
   11713             : 
   11714             : DESCRIPTION:
   11715             : This algorithm solves system of nonlinear equations
   11716             :     F[0](x[0], ..., x[n-1])   = 0
   11717             :     F[1](x[0], ..., x[n-1])   = 0
   11718             :     ...
   11719             :     F[M-1](x[0], ..., x[n-1]) = 0
   11720             : with M/N do not necessarily coincide.  Algorithm  converges  quadratically
   11721             : under following conditions:
   11722             :     * the solution set XS is nonempty
   11723             :     * for some xs in XS there exist such neighbourhood N(xs) that:
   11724             :       * vector function F(x) and its Jacobian J(x) are continuously
   11725             :         differentiable on N
   11726             :       * ||F(x)|| provides local error bound on N, i.e. there  exists  such
   11727             :         c1, that ||F(x)||>c1*distance(x,XS)
   11728             : Note that these conditions are much more weaker than usual non-singularity
   11729             : conditions. For example, algorithm will converge for any  affine  function
   11730             : F (whether its Jacobian singular or not).
   11731             : 
   11732             : 
   11733             : REQUIREMENTS:
   11734             : Algorithm will request following information during its operation:
   11735             : * function vector F[] and Jacobian matrix at given point X
   11736             : * value of merit function f(x)=F[0]^2(x)+...+F[M-1]^2(x) at given point X
   11737             : 
   11738             : 
   11739             : USAGE:
   11740             : 1. User initializes algorithm state with NLEQCreateLM() call
   11741             : 2. User tunes solver parameters with  NLEQSetCond(),  NLEQSetStpMax()  and
   11742             :    other functions
   11743             : 3. User  calls  NLEQSolve()  function  which  takes  algorithm  state  and
   11744             :    pointers (delegates, etc.) to callback functions which calculate  merit
   11745             :    function value and Jacobian.
   11746             : 4. User calls NLEQResults() to get solution
   11747             : 5. Optionally, user may call NLEQRestartFrom() to  solve  another  problem
   11748             :    with same parameters (N/M) but another starting  point  and/or  another
   11749             :    function vector. NLEQRestartFrom() allows to reuse already  initialized
   11750             :    structure.
   11751             : 
   11752             : 
   11753             : INPUT PARAMETERS:
   11754             :     N       -   space dimension, N>1:
   11755             :                 * if provided, only leading N elements of X are used
   11756             :                 * if not provided, determined automatically from size of X
   11757             :     M       -   system size
   11758             :     X       -   starting point
   11759             : 
   11760             : 
   11761             : OUTPUT PARAMETERS:
   11762             :     State   -   structure which stores algorithm state
   11763             : 
   11764             : 
   11765             : NOTES:
   11766             : 1. you may tune stopping conditions with NLEQSetCond() function
   11767             : 2. if target function contains exp() or other fast growing functions,  and
   11768             :    optimization algorithm makes too large steps which leads  to  overflow,
   11769             :    use NLEQSetStpMax() function to bound algorithm's steps.
   11770             : 3. this  algorithm  is  a  slightly  modified implementation of the method
   11771             :    described  in  'Levenberg-Marquardt  method  for constrained  nonlinear
   11772             :    equations with strong local convergence properties' by Christian Kanzow
   11773             :    Nobuo Yamashita and Masao Fukushima and further  developed  in  'On the
   11774             :    convergence of a New Levenberg-Marquardt Method'  by  Jin-yan  Fan  and
   11775             :    Ya-Xiang Yuan.
   11776             : 
   11777             : 
   11778             :   -- ALGLIB --
   11779             :      Copyright 20.08.2009 by Bochkanov Sergey
   11780             : *************************************************************************/
   11781           0 : void nleqcreatelm(ae_int_t n,
   11782             :      ae_int_t m,
   11783             :      /* Real    */ ae_vector* x,
   11784             :      nleqstate* state,
   11785             :      ae_state *_state)
   11786             : {
   11787             : 
   11788           0 :     _nleqstate_clear(state);
   11789             : 
   11790           0 :     ae_assert(n>=1, "NLEQCreateLM: N<1!", _state);
   11791           0 :     ae_assert(m>=1, "NLEQCreateLM: M<1!", _state);
   11792           0 :     ae_assert(x->cnt>=n, "NLEQCreateLM: Length(X)<N!", _state);
   11793           0 :     ae_assert(isfinitevector(x, n, _state), "NLEQCreateLM: X contains infinite or NaN values!", _state);
   11794             :     
   11795             :     /*
   11796             :      * Initialize
   11797             :      */
   11798           0 :     state->n = n;
   11799           0 :     state->m = m;
   11800           0 :     nleqsetcond(state, (double)(0), 0, _state);
   11801           0 :     nleqsetxrep(state, ae_false, _state);
   11802           0 :     nleqsetstpmax(state, (double)(0), _state);
   11803           0 :     ae_vector_set_length(&state->x, n, _state);
   11804           0 :     ae_vector_set_length(&state->xbase, n, _state);
   11805           0 :     ae_matrix_set_length(&state->j, m, n, _state);
   11806           0 :     ae_vector_set_length(&state->fi, m, _state);
   11807           0 :     ae_vector_set_length(&state->rightpart, n, _state);
   11808           0 :     ae_vector_set_length(&state->candstep, n, _state);
   11809           0 :     nleqrestartfrom(state, x, _state);
   11810           0 : }
   11811             : 
   11812             : 
   11813             : /*************************************************************************
   11814             : This function sets stopping conditions for the nonlinear solver
   11815             : 
   11816             : INPUT PARAMETERS:
   11817             :     State   -   structure which stores algorithm state
   11818             :     EpsF    -   >=0
   11819             :                 The subroutine finishes  its work if on k+1-th iteration
   11820             :                 the condition ||F||<=EpsF is satisfied
   11821             :     MaxIts  -   maximum number of iterations. If MaxIts=0, the  number  of
   11822             :                 iterations is unlimited.
   11823             : 
   11824             : Passing EpsF=0 and MaxIts=0 simultaneously will lead to  automatic
   11825             : stopping criterion selection (small EpsF).
   11826             : 
   11827             : NOTES:
   11828             : 
   11829             :   -- ALGLIB --
   11830             :      Copyright 20.08.2010 by Bochkanov Sergey
   11831             : *************************************************************************/
   11832           0 : void nleqsetcond(nleqstate* state,
   11833             :      double epsf,
   11834             :      ae_int_t maxits,
   11835             :      ae_state *_state)
   11836             : {
   11837             : 
   11838             : 
   11839           0 :     ae_assert(ae_isfinite(epsf, _state), "NLEQSetCond: EpsF is not finite number!", _state);
   11840           0 :     ae_assert(ae_fp_greater_eq(epsf,(double)(0)), "NLEQSetCond: negative EpsF!", _state);
   11841           0 :     ae_assert(maxits>=0, "NLEQSetCond: negative MaxIts!", _state);
   11842           0 :     if( ae_fp_eq(epsf,(double)(0))&&maxits==0 )
   11843             :     {
   11844           0 :         epsf = 1.0E-6;
   11845             :     }
   11846           0 :     state->epsf = epsf;
   11847           0 :     state->maxits = maxits;
   11848           0 : }
   11849             : 
   11850             : 
   11851             : /*************************************************************************
   11852             : This function turns on/off reporting.
   11853             : 
   11854             : INPUT PARAMETERS:
   11855             :     State   -   structure which stores algorithm state
   11856             :     NeedXRep-   whether iteration reports are needed or not
   11857             : 
   11858             : If NeedXRep is True, algorithm will call rep() callback function if  it is
   11859             : provided to NLEQSolve().
   11860             : 
   11861             :   -- ALGLIB --
   11862             :      Copyright 20.08.2010 by Bochkanov Sergey
   11863             : *************************************************************************/
   11864           0 : void nleqsetxrep(nleqstate* state, ae_bool needxrep, ae_state *_state)
   11865             : {
   11866             : 
   11867             : 
   11868           0 :     state->xrep = needxrep;
   11869           0 : }
   11870             : 
   11871             : 
   11872             : /*************************************************************************
   11873             : This function sets maximum step length
   11874             : 
   11875             : INPUT PARAMETERS:
   11876             :     State   -   structure which stores algorithm state
   11877             :     StpMax  -   maximum step length, >=0. Set StpMax to 0.0,  if you don't
   11878             :                 want to limit step length.
   11879             : 
   11880             : Use this subroutine when target function  contains  exp()  or  other  fast
   11881             : growing functions, and algorithm makes  too  large  steps  which  lead  to
   11882             : overflow. This function allows us to reject steps that are too large  (and
   11883             : therefore expose us to the possible overflow) without actually calculating
   11884             : function value at the x+stp*d.
   11885             : 
   11886             :   -- ALGLIB --
   11887             :      Copyright 20.08.2010 by Bochkanov Sergey
   11888             : *************************************************************************/
   11889           0 : void nleqsetstpmax(nleqstate* state, double stpmax, ae_state *_state)
   11890             : {
   11891             : 
   11892             : 
   11893           0 :     ae_assert(ae_isfinite(stpmax, _state), "NLEQSetStpMax: StpMax is not finite!", _state);
   11894           0 :     ae_assert(ae_fp_greater_eq(stpmax,(double)(0)), "NLEQSetStpMax: StpMax<0!", _state);
   11895           0 :     state->stpmax = stpmax;
   11896           0 : }
   11897             : 
   11898             : 
   11899             : /*************************************************************************
   11900             : 
   11901             :   -- ALGLIB --
   11902             :      Copyright 20.03.2009 by Bochkanov Sergey
   11903             : *************************************************************************/
   11904           0 : ae_bool nleqiteration(nleqstate* state, ae_state *_state)
   11905             : {
   11906             :     ae_int_t n;
   11907             :     ae_int_t m;
   11908             :     ae_int_t i;
   11909             :     double lambdaup;
   11910             :     double lambdadown;
   11911             :     double lambdav;
   11912             :     double rho;
   11913             :     double mu;
   11914             :     double stepnorm;
   11915             :     ae_bool b;
   11916             :     ae_bool result;
   11917             : 
   11918             : 
   11919             :     
   11920             :     /*
   11921             :      * Reverse communication preparations
   11922             :      * I know it looks ugly, but it works the same way
   11923             :      * anywhere from C++ to Python.
   11924             :      *
   11925             :      * This code initializes locals by:
   11926             :      * * random values determined during code
   11927             :      *   generation - on first subroutine call
   11928             :      * * values from previous call - on subsequent calls
   11929             :      */
   11930           0 :     if( state->rstate.stage>=0 )
   11931             :     {
   11932           0 :         n = state->rstate.ia.ptr.p_int[0];
   11933           0 :         m = state->rstate.ia.ptr.p_int[1];
   11934           0 :         i = state->rstate.ia.ptr.p_int[2];
   11935           0 :         b = state->rstate.ba.ptr.p_bool[0];
   11936           0 :         lambdaup = state->rstate.ra.ptr.p_double[0];
   11937           0 :         lambdadown = state->rstate.ra.ptr.p_double[1];
   11938           0 :         lambdav = state->rstate.ra.ptr.p_double[2];
   11939           0 :         rho = state->rstate.ra.ptr.p_double[3];
   11940           0 :         mu = state->rstate.ra.ptr.p_double[4];
   11941           0 :         stepnorm = state->rstate.ra.ptr.p_double[5];
   11942             :     }
   11943             :     else
   11944             :     {
   11945           0 :         n = 359;
   11946           0 :         m = -58;
   11947           0 :         i = -919;
   11948           0 :         b = ae_true;
   11949           0 :         lambdaup = 81;
   11950           0 :         lambdadown = 255;
   11951           0 :         lambdav = 74;
   11952           0 :         rho = -788;
   11953           0 :         mu = 809;
   11954           0 :         stepnorm = 205;
   11955             :     }
   11956           0 :     if( state->rstate.stage==0 )
   11957             :     {
   11958           0 :         goto lbl_0;
   11959             :     }
   11960           0 :     if( state->rstate.stage==1 )
   11961             :     {
   11962           0 :         goto lbl_1;
   11963             :     }
   11964           0 :     if( state->rstate.stage==2 )
   11965             :     {
   11966           0 :         goto lbl_2;
   11967             :     }
   11968           0 :     if( state->rstate.stage==3 )
   11969             :     {
   11970           0 :         goto lbl_3;
   11971             :     }
   11972           0 :     if( state->rstate.stage==4 )
   11973             :     {
   11974           0 :         goto lbl_4;
   11975             :     }
   11976             :     
   11977             :     /*
   11978             :      * Routine body
   11979             :      */
   11980             :     
   11981             :     /*
   11982             :      * Prepare
   11983             :      */
   11984           0 :     n = state->n;
   11985           0 :     m = state->m;
   11986           0 :     state->repterminationtype = 0;
   11987           0 :     state->repiterationscount = 0;
   11988           0 :     state->repnfunc = 0;
   11989           0 :     state->repnjac = 0;
   11990             :     
   11991             :     /*
   11992             :      * Calculate F/G, initialize algorithm
   11993             :      */
   11994           0 :     nleq_clearrequestfields(state, _state);
   11995           0 :     state->needf = ae_true;
   11996           0 :     state->rstate.stage = 0;
   11997           0 :     goto lbl_rcomm;
   11998           0 : lbl_0:
   11999           0 :     state->needf = ae_false;
   12000           0 :     state->repnfunc = state->repnfunc+1;
   12001           0 :     ae_v_move(&state->xbase.ptr.p_double[0], 1, &state->x.ptr.p_double[0], 1, ae_v_len(0,n-1));
   12002           0 :     state->fbase = state->f;
   12003           0 :     state->fprev = ae_maxrealnumber;
   12004           0 :     if( !state->xrep )
   12005             :     {
   12006           0 :         goto lbl_5;
   12007             :     }
   12008             :     
   12009             :     /*
   12010             :      * progress report
   12011             :      */
   12012           0 :     nleq_clearrequestfields(state, _state);
   12013           0 :     state->xupdated = ae_true;
   12014           0 :     state->rstate.stage = 1;
   12015           0 :     goto lbl_rcomm;
   12016           0 : lbl_1:
   12017           0 :     state->xupdated = ae_false;
   12018           0 : lbl_5:
   12019           0 :     if( ae_fp_less_eq(state->f,ae_sqr(state->epsf, _state)) )
   12020             :     {
   12021           0 :         state->repterminationtype = 1;
   12022           0 :         result = ae_false;
   12023           0 :         return result;
   12024             :     }
   12025             :     
   12026             :     /*
   12027             :      * Main cycle
   12028             :      */
   12029           0 :     lambdaup = (double)(10);
   12030           0 :     lambdadown = 0.3;
   12031           0 :     lambdav = 0.001;
   12032           0 :     rho = (double)(1);
   12033           0 : lbl_7:
   12034             :     if( ae_false )
   12035             :     {
   12036             :         goto lbl_8;
   12037             :     }
   12038             :     
   12039             :     /*
   12040             :      * Get Jacobian;
   12041             :      * before we get to this point we already have State.XBase filled
   12042             :      * with current point and State.FBase filled with function value
   12043             :      * at XBase
   12044             :      */
   12045           0 :     nleq_clearrequestfields(state, _state);
   12046           0 :     state->needfij = ae_true;
   12047           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->xbase.ptr.p_double[0], 1, ae_v_len(0,n-1));
   12048           0 :     state->rstate.stage = 2;
   12049           0 :     goto lbl_rcomm;
   12050           0 : lbl_2:
   12051           0 :     state->needfij = ae_false;
   12052           0 :     state->repnfunc = state->repnfunc+1;
   12053           0 :     state->repnjac = state->repnjac+1;
   12054           0 :     rmatrixmv(n, m, &state->j, 0, 0, 1, &state->fi, 0, &state->rightpart, 0, _state);
   12055           0 :     ae_v_muld(&state->rightpart.ptr.p_double[0], 1, ae_v_len(0,n-1), -1);
   12056             :     
   12057             :     /*
   12058             :      * Inner cycle: find good lambda
   12059             :      */
   12060           0 : lbl_9:
   12061             :     if( ae_false )
   12062             :     {
   12063             :         goto lbl_10;
   12064             :     }
   12065             :     
   12066             :     /*
   12067             :      * Solve (J^T*J + (Lambda+Mu)*I)*y = J^T*F
   12068             :      * to get step d=-y where:
   12069             :      * * Mu=||F|| - is damping parameter for nonlinear system
   12070             :      * * Lambda   - is additional Levenberg-Marquardt parameter
   12071             :      *              for better convergence when far away from minimum
   12072             :      */
   12073           0 :     for(i=0; i<=n-1; i++)
   12074             :     {
   12075           0 :         state->candstep.ptr.p_double[i] = (double)(0);
   12076             :     }
   12077           0 :     fblssolvecgx(&state->j, m, n, lambdav, &state->rightpart, &state->candstep, &state->cgbuf, _state);
   12078             :     
   12079             :     /*
   12080             :      * Normalize step (it must be no more than StpMax)
   12081             :      */
   12082           0 :     stepnorm = (double)(0);
   12083           0 :     for(i=0; i<=n-1; i++)
   12084             :     {
   12085           0 :         if( ae_fp_neq(state->candstep.ptr.p_double[i],(double)(0)) )
   12086             :         {
   12087           0 :             stepnorm = (double)(1);
   12088           0 :             break;
   12089             :         }
   12090             :     }
   12091           0 :     linminnormalized(&state->candstep, &stepnorm, n, _state);
   12092           0 :     if( ae_fp_neq(state->stpmax,(double)(0)) )
   12093             :     {
   12094           0 :         stepnorm = ae_minreal(stepnorm, state->stpmax, _state);
   12095             :     }
   12096             :     
   12097             :     /*
   12098             :      * Test new step - is it good enough?
   12099             :      * * if not, Lambda is increased and we try again.
   12100             :      * * if step is good, we decrease Lambda and move on.
   12101             :      *
   12102             :      * We can break this cycle on two occasions:
   12103             :      * * step is so small that x+step==x (in floating point arithmetics)
   12104             :      * * lambda is so large
   12105             :      */
   12106           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->xbase.ptr.p_double[0], 1, ae_v_len(0,n-1));
   12107           0 :     ae_v_addd(&state->x.ptr.p_double[0], 1, &state->candstep.ptr.p_double[0], 1, ae_v_len(0,n-1), stepnorm);
   12108           0 :     b = ae_true;
   12109           0 :     for(i=0; i<=n-1; i++)
   12110             :     {
   12111           0 :         if( ae_fp_neq(state->x.ptr.p_double[i],state->xbase.ptr.p_double[i]) )
   12112             :         {
   12113           0 :             b = ae_false;
   12114           0 :             break;
   12115             :         }
   12116             :     }
   12117           0 :     if( b )
   12118             :     {
   12119             :         
   12120             :         /*
   12121             :          * Step is too small, force zero step and break
   12122             :          */
   12123           0 :         stepnorm = (double)(0);
   12124           0 :         ae_v_move(&state->x.ptr.p_double[0], 1, &state->xbase.ptr.p_double[0], 1, ae_v_len(0,n-1));
   12125           0 :         state->f = state->fbase;
   12126           0 :         goto lbl_10;
   12127             :     }
   12128           0 :     nleq_clearrequestfields(state, _state);
   12129           0 :     state->needf = ae_true;
   12130           0 :     state->rstate.stage = 3;
   12131           0 :     goto lbl_rcomm;
   12132           0 : lbl_3:
   12133           0 :     state->needf = ae_false;
   12134           0 :     state->repnfunc = state->repnfunc+1;
   12135           0 :     if( ae_fp_less(state->f,state->fbase) )
   12136             :     {
   12137             :         
   12138             :         /*
   12139             :          * function value decreased, move on
   12140             :          */
   12141           0 :         nleq_decreaselambda(&lambdav, &rho, lambdadown, _state);
   12142           0 :         goto lbl_10;
   12143             :     }
   12144           0 :     if( !nleq_increaselambda(&lambdav, &rho, lambdaup, _state) )
   12145             :     {
   12146             :         
   12147             :         /*
   12148             :          * Lambda is too large (near overflow), force zero step and break
   12149             :          */
   12150           0 :         stepnorm = (double)(0);
   12151           0 :         ae_v_move(&state->x.ptr.p_double[0], 1, &state->xbase.ptr.p_double[0], 1, ae_v_len(0,n-1));
   12152           0 :         state->f = state->fbase;
   12153           0 :         goto lbl_10;
   12154             :     }
   12155           0 :     goto lbl_9;
   12156           0 : lbl_10:
   12157             :     
   12158             :     /*
   12159             :      * Accept step:
   12160             :      * * new position
   12161             :      * * new function value
   12162             :      */
   12163           0 :     state->fbase = state->f;
   12164           0 :     ae_v_addd(&state->xbase.ptr.p_double[0], 1, &state->candstep.ptr.p_double[0], 1, ae_v_len(0,n-1), stepnorm);
   12165           0 :     state->repiterationscount = state->repiterationscount+1;
   12166             :     
   12167             :     /*
   12168             :      * Report new iteration
   12169             :      */
   12170           0 :     if( !state->xrep )
   12171             :     {
   12172           0 :         goto lbl_11;
   12173             :     }
   12174           0 :     nleq_clearrequestfields(state, _state);
   12175           0 :     state->xupdated = ae_true;
   12176           0 :     state->f = state->fbase;
   12177           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->xbase.ptr.p_double[0], 1, ae_v_len(0,n-1));
   12178           0 :     state->rstate.stage = 4;
   12179           0 :     goto lbl_rcomm;
   12180           0 : lbl_4:
   12181           0 :     state->xupdated = ae_false;
   12182           0 : lbl_11:
   12183             :     
   12184             :     /*
   12185             :      * Test stopping conditions on F, step (zero/non-zero) and MaxIts;
   12186             :      * If one of the conditions is met, RepTerminationType is changed.
   12187             :      */
   12188           0 :     if( ae_fp_less_eq(ae_sqrt(state->f, _state),state->epsf) )
   12189             :     {
   12190           0 :         state->repterminationtype = 1;
   12191             :     }
   12192           0 :     if( ae_fp_eq(stepnorm,(double)(0))&&state->repterminationtype==0 )
   12193             :     {
   12194           0 :         state->repterminationtype = -4;
   12195             :     }
   12196           0 :     if( state->repiterationscount>=state->maxits&&state->maxits>0 )
   12197             :     {
   12198           0 :         state->repterminationtype = 5;
   12199             :     }
   12200           0 :     if( state->repterminationtype!=0 )
   12201             :     {
   12202           0 :         goto lbl_8;
   12203             :     }
   12204             :     
   12205             :     /*
   12206             :      * Now, iteration is finally over
   12207             :      */
   12208           0 :     goto lbl_7;
   12209           0 : lbl_8:
   12210           0 :     result = ae_false;
   12211           0 :     return result;
   12212             :     
   12213             :     /*
   12214             :      * Saving state
   12215             :      */
   12216           0 : lbl_rcomm:
   12217           0 :     result = ae_true;
   12218           0 :     state->rstate.ia.ptr.p_int[0] = n;
   12219           0 :     state->rstate.ia.ptr.p_int[1] = m;
   12220           0 :     state->rstate.ia.ptr.p_int[2] = i;
   12221           0 :     state->rstate.ba.ptr.p_bool[0] = b;
   12222           0 :     state->rstate.ra.ptr.p_double[0] = lambdaup;
   12223           0 :     state->rstate.ra.ptr.p_double[1] = lambdadown;
   12224           0 :     state->rstate.ra.ptr.p_double[2] = lambdav;
   12225           0 :     state->rstate.ra.ptr.p_double[3] = rho;
   12226           0 :     state->rstate.ra.ptr.p_double[4] = mu;
   12227           0 :     state->rstate.ra.ptr.p_double[5] = stepnorm;
   12228           0 :     return result;
   12229             : }
   12230             : 
   12231             : 
   12232             : /*************************************************************************
   12233             : NLEQ solver results
   12234             : 
   12235             : INPUT PARAMETERS:
   12236             :     State   -   algorithm state.
   12237             : 
   12238             : OUTPUT PARAMETERS:
   12239             :     X       -   array[0..N-1], solution
   12240             :     Rep     -   optimization report:
   12241             :                 * Rep.TerminationType completetion code:
   12242             :                     * -4    ERROR:  algorithm   has   converged   to   the
   12243             :                             stationary point Xf which is local minimum  of
   12244             :                             f=F[0]^2+...+F[m-1]^2, but is not solution  of
   12245             :                             nonlinear system.
   12246             :                     *  1    sqrt(f)<=EpsF.
   12247             :                     *  5    MaxIts steps was taken
   12248             :                     *  7    stopping conditions are too stringent,
   12249             :                             further improvement is impossible
   12250             :                 * Rep.IterationsCount contains iterations count
   12251             :                 * NFEV countains number of function calculations
   12252             :                 * ActiveConstraints contains number of active constraints
   12253             : 
   12254             :   -- ALGLIB --
   12255             :      Copyright 20.08.2009 by Bochkanov Sergey
   12256             : *************************************************************************/
   12257           0 : void nleqresults(nleqstate* state,
   12258             :      /* Real    */ ae_vector* x,
   12259             :      nleqreport* rep,
   12260             :      ae_state *_state)
   12261             : {
   12262             : 
   12263           0 :     ae_vector_clear(x);
   12264           0 :     _nleqreport_clear(rep);
   12265             : 
   12266           0 :     nleqresultsbuf(state, x, rep, _state);
   12267           0 : }
   12268             : 
   12269             : 
   12270             : /*************************************************************************
   12271             : NLEQ solver results
   12272             : 
   12273             : Buffered implementation of NLEQResults(), which uses pre-allocated  buffer
   12274             : to store X[]. If buffer size is  too  small,  it  resizes  buffer.  It  is
   12275             : intended to be used in the inner cycles of performance critical algorithms
   12276             : where array reallocation penalty is too large to be ignored.
   12277             : 
   12278             :   -- ALGLIB --
   12279             :      Copyright 20.08.2009 by Bochkanov Sergey
   12280             : *************************************************************************/
   12281           0 : void nleqresultsbuf(nleqstate* state,
   12282             :      /* Real    */ ae_vector* x,
   12283             :      nleqreport* rep,
   12284             :      ae_state *_state)
   12285             : {
   12286             : 
   12287             : 
   12288           0 :     if( x->cnt<state->n )
   12289             :     {
   12290           0 :         ae_vector_set_length(x, state->n, _state);
   12291             :     }
   12292           0 :     ae_v_move(&x->ptr.p_double[0], 1, &state->xbase.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   12293           0 :     rep->iterationscount = state->repiterationscount;
   12294           0 :     rep->nfunc = state->repnfunc;
   12295           0 :     rep->njac = state->repnjac;
   12296           0 :     rep->terminationtype = state->repterminationtype;
   12297           0 : }
   12298             : 
   12299             : 
   12300             : /*************************************************************************
   12301             : This  subroutine  restarts  CG  algorithm from new point. All optimization
   12302             : parameters are left unchanged.
   12303             : 
   12304             : This  function  allows  to  solve multiple  optimization  problems  (which
   12305             : must have same number of dimensions) without object reallocation penalty.
   12306             : 
   12307             : INPUT PARAMETERS:
   12308             :     State   -   structure used for reverse communication previously
   12309             :                 allocated with MinCGCreate call.
   12310             :     X       -   new starting point.
   12311             :     BndL    -   new lower bounds
   12312             :     BndU    -   new upper bounds
   12313             : 
   12314             :   -- ALGLIB --
   12315             :      Copyright 30.07.2010 by Bochkanov Sergey
   12316             : *************************************************************************/
   12317           0 : void nleqrestartfrom(nleqstate* state,
   12318             :      /* Real    */ ae_vector* x,
   12319             :      ae_state *_state)
   12320             : {
   12321             : 
   12322             : 
   12323           0 :     ae_assert(x->cnt>=state->n, "NLEQRestartFrom: Length(X)<N!", _state);
   12324           0 :     ae_assert(isfinitevector(x, state->n, _state), "NLEQRestartFrom: X contains infinite or NaN values!", _state);
   12325           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &x->ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   12326           0 :     ae_vector_set_length(&state->rstate.ia, 2+1, _state);
   12327           0 :     ae_vector_set_length(&state->rstate.ba, 0+1, _state);
   12328           0 :     ae_vector_set_length(&state->rstate.ra, 5+1, _state);
   12329           0 :     state->rstate.stage = -1;
   12330           0 :     nleq_clearrequestfields(state, _state);
   12331           0 : }
   12332             : 
   12333             : 
   12334             : /*************************************************************************
   12335             : Clears request fileds (to be sure that we don't forgot to clear something)
   12336             : *************************************************************************/
   12337           0 : static void nleq_clearrequestfields(nleqstate* state, ae_state *_state)
   12338             : {
   12339             : 
   12340             : 
   12341           0 :     state->needf = ae_false;
   12342           0 :     state->needfij = ae_false;
   12343           0 :     state->xupdated = ae_false;
   12344           0 : }
   12345             : 
   12346             : 
   12347             : /*************************************************************************
   12348             : Increases lambda, returns False when there is a danger of overflow
   12349             : *************************************************************************/
   12350           0 : static ae_bool nleq_increaselambda(double* lambdav,
   12351             :      double* nu,
   12352             :      double lambdaup,
   12353             :      ae_state *_state)
   12354             : {
   12355             :     double lnlambda;
   12356             :     double lnnu;
   12357             :     double lnlambdaup;
   12358             :     double lnmax;
   12359             :     ae_bool result;
   12360             : 
   12361             : 
   12362           0 :     result = ae_false;
   12363           0 :     lnlambda = ae_log(*lambdav, _state);
   12364           0 :     lnlambdaup = ae_log(lambdaup, _state);
   12365           0 :     lnnu = ae_log(*nu, _state);
   12366           0 :     lnmax = 0.5*ae_log(ae_maxrealnumber, _state);
   12367           0 :     if( ae_fp_greater(lnlambda+lnlambdaup+lnnu,lnmax) )
   12368             :     {
   12369           0 :         return result;
   12370             :     }
   12371           0 :     if( ae_fp_greater(lnnu+ae_log((double)(2), _state),lnmax) )
   12372             :     {
   12373           0 :         return result;
   12374             :     }
   12375           0 :     *lambdav = *lambdav*lambdaup*(*nu);
   12376           0 :     *nu = *nu*2;
   12377           0 :     result = ae_true;
   12378           0 :     return result;
   12379             : }
   12380             : 
   12381             : 
   12382             : /*************************************************************************
   12383             : Decreases lambda, but leaves it unchanged when there is danger of underflow.
   12384             : *************************************************************************/
   12385           0 : static void nleq_decreaselambda(double* lambdav,
   12386             :      double* nu,
   12387             :      double lambdadown,
   12388             :      ae_state *_state)
   12389             : {
   12390             : 
   12391             : 
   12392           0 :     *nu = (double)(1);
   12393           0 :     if( ae_fp_less(ae_log(*lambdav, _state)+ae_log(lambdadown, _state),ae_log(ae_minrealnumber, _state)) )
   12394             :     {
   12395           0 :         *lambdav = ae_minrealnumber;
   12396             :     }
   12397             :     else
   12398             :     {
   12399           0 :         *lambdav = *lambdav*lambdadown;
   12400             :     }
   12401           0 : }
   12402             : 
   12403             : 
   12404           0 : void _nleqstate_init(void* _p, ae_state *_state, ae_bool make_automatic)
   12405             : {
   12406           0 :     nleqstate *p = (nleqstate*)_p;
   12407           0 :     ae_touch_ptr((void*)p);
   12408           0 :     ae_vector_init(&p->x, 0, DT_REAL, _state, make_automatic);
   12409           0 :     ae_vector_init(&p->fi, 0, DT_REAL, _state, make_automatic);
   12410           0 :     ae_matrix_init(&p->j, 0, 0, DT_REAL, _state, make_automatic);
   12411           0 :     _rcommstate_init(&p->rstate, _state, make_automatic);
   12412           0 :     ae_vector_init(&p->xbase, 0, DT_REAL, _state, make_automatic);
   12413           0 :     ae_vector_init(&p->candstep, 0, DT_REAL, _state, make_automatic);
   12414           0 :     ae_vector_init(&p->rightpart, 0, DT_REAL, _state, make_automatic);
   12415           0 :     ae_vector_init(&p->cgbuf, 0, DT_REAL, _state, make_automatic);
   12416           0 : }
   12417             : 
   12418             : 
   12419           0 : void _nleqstate_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   12420             : {
   12421           0 :     nleqstate *dst = (nleqstate*)_dst;
   12422           0 :     nleqstate *src = (nleqstate*)_src;
   12423           0 :     dst->n = src->n;
   12424           0 :     dst->m = src->m;
   12425           0 :     dst->epsf = src->epsf;
   12426           0 :     dst->maxits = src->maxits;
   12427           0 :     dst->xrep = src->xrep;
   12428           0 :     dst->stpmax = src->stpmax;
   12429           0 :     ae_vector_init_copy(&dst->x, &src->x, _state, make_automatic);
   12430           0 :     dst->f = src->f;
   12431           0 :     ae_vector_init_copy(&dst->fi, &src->fi, _state, make_automatic);
   12432           0 :     ae_matrix_init_copy(&dst->j, &src->j, _state, make_automatic);
   12433           0 :     dst->needf = src->needf;
   12434           0 :     dst->needfij = src->needfij;
   12435           0 :     dst->xupdated = src->xupdated;
   12436           0 :     _rcommstate_init_copy(&dst->rstate, &src->rstate, _state, make_automatic);
   12437           0 :     dst->repiterationscount = src->repiterationscount;
   12438           0 :     dst->repnfunc = src->repnfunc;
   12439           0 :     dst->repnjac = src->repnjac;
   12440           0 :     dst->repterminationtype = src->repterminationtype;
   12441           0 :     ae_vector_init_copy(&dst->xbase, &src->xbase, _state, make_automatic);
   12442           0 :     dst->fbase = src->fbase;
   12443           0 :     dst->fprev = src->fprev;
   12444           0 :     ae_vector_init_copy(&dst->candstep, &src->candstep, _state, make_automatic);
   12445           0 :     ae_vector_init_copy(&dst->rightpart, &src->rightpart, _state, make_automatic);
   12446           0 :     ae_vector_init_copy(&dst->cgbuf, &src->cgbuf, _state, make_automatic);
   12447           0 : }
   12448             : 
   12449             : 
   12450           0 : void _nleqstate_clear(void* _p)
   12451             : {
   12452           0 :     nleqstate *p = (nleqstate*)_p;
   12453           0 :     ae_touch_ptr((void*)p);
   12454           0 :     ae_vector_clear(&p->x);
   12455           0 :     ae_vector_clear(&p->fi);
   12456           0 :     ae_matrix_clear(&p->j);
   12457           0 :     _rcommstate_clear(&p->rstate);
   12458           0 :     ae_vector_clear(&p->xbase);
   12459           0 :     ae_vector_clear(&p->candstep);
   12460           0 :     ae_vector_clear(&p->rightpart);
   12461           0 :     ae_vector_clear(&p->cgbuf);
   12462           0 : }
   12463             : 
   12464             : 
   12465           0 : void _nleqstate_destroy(void* _p)
   12466             : {
   12467           0 :     nleqstate *p = (nleqstate*)_p;
   12468           0 :     ae_touch_ptr((void*)p);
   12469           0 :     ae_vector_destroy(&p->x);
   12470           0 :     ae_vector_destroy(&p->fi);
   12471           0 :     ae_matrix_destroy(&p->j);
   12472           0 :     _rcommstate_destroy(&p->rstate);
   12473           0 :     ae_vector_destroy(&p->xbase);
   12474           0 :     ae_vector_destroy(&p->candstep);
   12475           0 :     ae_vector_destroy(&p->rightpart);
   12476           0 :     ae_vector_destroy(&p->cgbuf);
   12477           0 : }
   12478             : 
   12479             : 
   12480           0 : void _nleqreport_init(void* _p, ae_state *_state, ae_bool make_automatic)
   12481             : {
   12482           0 :     nleqreport *p = (nleqreport*)_p;
   12483           0 :     ae_touch_ptr((void*)p);
   12484           0 : }
   12485             : 
   12486             : 
   12487           0 : void _nleqreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   12488             : {
   12489           0 :     nleqreport *dst = (nleqreport*)_dst;
   12490           0 :     nleqreport *src = (nleqreport*)_src;
   12491           0 :     dst->iterationscount = src->iterationscount;
   12492           0 :     dst->nfunc = src->nfunc;
   12493           0 :     dst->njac = src->njac;
   12494           0 :     dst->terminationtype = src->terminationtype;
   12495           0 : }
   12496             : 
   12497             : 
   12498           0 : void _nleqreport_clear(void* _p)
   12499             : {
   12500           0 :     nleqreport *p = (nleqreport*)_p;
   12501           0 :     ae_touch_ptr((void*)p);
   12502           0 : }
   12503             : 
   12504             : 
   12505           0 : void _nleqreport_destroy(void* _p)
   12506             : {
   12507           0 :     nleqreport *p = (nleqreport*)_p;
   12508           0 :     ae_touch_ptr((void*)p);
   12509           0 : }
   12510             : 
   12511             : 
   12512             : #endif
   12513             : #if defined(AE_COMPILE_DIRECTSPARSESOLVERS) || !defined(AE_PARTIAL_BUILD)
   12514             : 
   12515             : 
   12516             : /*************************************************************************
   12517             : Sparse linear solver for A*x=b with N*N  sparse  real  symmetric  positive
   12518             : definite matrix A, N*1 vectors x and b.
   12519             : 
   12520             : This solver  converts  input  matrix  to  SKS  format,  performs  Cholesky
   12521             : factorization using  SKS  Cholesky  subroutine  (works  well  for  limited
   12522             : bandwidth matrices) and uses sparse triangular solvers to get solution  of
   12523             : the original system.
   12524             : 
   12525             : INPUT PARAMETERS
   12526             :     A       -   sparse matrix, must be NxN exactly
   12527             :     IsUpper -   which half of A is provided (another half is ignored)
   12528             :     B       -   array[0..N-1], right part
   12529             : 
   12530             : OUTPUT PARAMETERS
   12531             :     X       -   array[N], it contains:
   12532             :                 * rep.terminationtype>0    =>  solution
   12533             :                 * rep.terminationtype=-3   =>  filled by zeros
   12534             :     Rep     -   solver report, following fields are set:
   12535             :                 * rep.terminationtype - solver status; >0 for success,
   12536             :                   set to -3 on failure (degenerate or non-SPD system).
   12537             : 
   12538             :   -- ALGLIB --
   12539             :      Copyright 26.12.2017 by Bochkanov Sergey
   12540             : *************************************************************************/
   12541           0 : void sparsespdsolvesks(sparsematrix* a,
   12542             :      ae_bool isupper,
   12543             :      /* Real    */ ae_vector* b,
   12544             :      /* Real    */ ae_vector* x,
   12545             :      sparsesolverreport* rep,
   12546             :      ae_state *_state)
   12547             : {
   12548             :     ae_frame _frame_block;
   12549             :     ae_int_t i;
   12550             :     sparsematrix a2;
   12551             :     ae_int_t n;
   12552             : 
   12553           0 :     ae_frame_make(_state, &_frame_block);
   12554           0 :     memset(&a2, 0, sizeof(a2));
   12555           0 :     ae_vector_clear(x);
   12556           0 :     _sparsesolverreport_clear(rep);
   12557           0 :     _sparsematrix_init(&a2, _state, ae_true);
   12558             : 
   12559           0 :     n = sparsegetnrows(a, _state);
   12560           0 :     ae_assert(n>0, "SparseSPDSolveSKS: N<=0", _state);
   12561           0 :     ae_assert(sparsegetnrows(a, _state)==n, "SparseSPDSolveSKS: rows(A)!=N", _state);
   12562           0 :     ae_assert(sparsegetncols(a, _state)==n, "SparseSPDSolveSKS: cols(A)!=N", _state);
   12563           0 :     ae_assert(b->cnt>=n, "SparseSPDSolveSKS: length(B)<N", _state);
   12564           0 :     ae_assert(isfinitevector(b, n, _state), "SparseSPDSolveSKS: B contains infinities or NANs", _state);
   12565           0 :     directsparsesolvers_initreport(rep, _state);
   12566           0 :     ae_vector_set_length(x, n, _state);
   12567           0 :     sparsecopytosks(a, &a2, _state);
   12568           0 :     if( !sparsecholeskyskyline(&a2, n, isupper, _state) )
   12569             :     {
   12570           0 :         rep->terminationtype = -3;
   12571           0 :         for(i=0; i<=n-1; i++)
   12572             :         {
   12573           0 :             x->ptr.p_double[i] = (double)(0);
   12574             :         }
   12575           0 :         ae_frame_leave(_state);
   12576           0 :         return;
   12577             :     }
   12578           0 :     for(i=0; i<=n-1; i++)
   12579             :     {
   12580           0 :         x->ptr.p_double[i] = b->ptr.p_double[i];
   12581             :     }
   12582           0 :     if( isupper )
   12583             :     {
   12584           0 :         sparsetrsv(&a2, isupper, ae_false, 1, x, _state);
   12585           0 :         sparsetrsv(&a2, isupper, ae_false, 0, x, _state);
   12586             :     }
   12587             :     else
   12588             :     {
   12589           0 :         sparsetrsv(&a2, isupper, ae_false, 0, x, _state);
   12590           0 :         sparsetrsv(&a2, isupper, ae_false, 1, x, _state);
   12591             :     }
   12592           0 :     rep->terminationtype = 1;
   12593           0 :     ae_frame_leave(_state);
   12594             : }
   12595             : 
   12596             : 
   12597             : /*************************************************************************
   12598             : Sparse linear solver for A*x=b with N*N  sparse  real  symmetric  positive
   12599             : definite matrix A, N*1 vectors x and b.
   12600             : 
   12601             : This solver  converts  input  matrix  to  CRS  format,  performs  Cholesky
   12602             : factorization using supernodal Cholesky  decomposition  with  permutation-
   12603             : reducing ordering and uses sparse triangular solver to get solution of the
   12604             : original system.
   12605             : 
   12606             : INPUT PARAMETERS
   12607             :     A       -   sparse matrix, must be NxN exactly
   12608             :     IsUpper -   which half of A is provided (another half is ignored)
   12609             :     B       -   array[N], right part
   12610             : 
   12611             : OUTPUT PARAMETERS
   12612             :     X       -   array[N], it contains:
   12613             :                 * rep.terminationtype>0    =>  solution
   12614             :                 * rep.terminationtype=-3   =>  filled by zeros
   12615             :     Rep     -   solver report, following fields are set:
   12616             :                 * rep.terminationtype - solver status; >0 for success,
   12617             :                   set to -3 on failure (degenerate or non-SPD system).
   12618             : 
   12619             :   -- ALGLIB --
   12620             :      Copyright 26.12.2017 by Bochkanov Sergey
   12621             : *************************************************************************/
   12622           0 : void sparsespdsolve(sparsematrix* a,
   12623             :      ae_bool isupper,
   12624             :      /* Real    */ ae_vector* b,
   12625             :      /* Real    */ ae_vector* x,
   12626             :      sparsesolverreport* rep,
   12627             :      ae_state *_state)
   12628             : {
   12629             :     ae_frame _frame_block;
   12630             :     ae_int_t i;
   12631             :     ae_int_t j;
   12632             :     sparsematrix a2;
   12633             :     ae_int_t n;
   12634             :     double v;
   12635             :     ae_vector p;
   12636             : 
   12637           0 :     ae_frame_make(_state, &_frame_block);
   12638           0 :     memset(&a2, 0, sizeof(a2));
   12639           0 :     memset(&p, 0, sizeof(p));
   12640           0 :     ae_vector_clear(x);
   12641           0 :     _sparsesolverreport_clear(rep);
   12642           0 :     _sparsematrix_init(&a2, _state, ae_true);
   12643           0 :     ae_vector_init(&p, 0, DT_INT, _state, ae_true);
   12644             : 
   12645           0 :     n = sparsegetnrows(a, _state);
   12646           0 :     ae_assert(n>0, "SparseSPDSolve: N<=0", _state);
   12647           0 :     ae_assert(sparsegetnrows(a, _state)==n, "SparseSPDSolve: rows(A)!=N", _state);
   12648           0 :     ae_assert(sparsegetncols(a, _state)==n, "SparseSPDSolve: cols(A)!=N", _state);
   12649           0 :     ae_assert(b->cnt>=n, "SparseSPDSolve: length(B)<N", _state);
   12650           0 :     ae_assert(isfinitevector(b, n, _state), "SparseSPDSolve: B contains infinities or NANs", _state);
   12651           0 :     directsparsesolvers_initreport(rep, _state);
   12652           0 :     sparsecopytocrs(a, &a2, _state);
   12653           0 :     if( !sparsecholeskyp(&a2, isupper, &p, _state) )
   12654             :     {
   12655           0 :         rep->terminationtype = -3;
   12656           0 :         rsetallocv(n, 0.0, x, _state);
   12657           0 :         ae_frame_leave(_state);
   12658           0 :         return;
   12659             :     }
   12660           0 :     rcopyallocv(n, b, x, _state);
   12661           0 :     for(i=0; i<=n-1; i++)
   12662             :     {
   12663           0 :         j = p.ptr.p_int[i];
   12664           0 :         v = x->ptr.p_double[i];
   12665           0 :         x->ptr.p_double[i] = x->ptr.p_double[j];
   12666           0 :         x->ptr.p_double[j] = v;
   12667             :     }
   12668           0 :     if( isupper )
   12669             :     {
   12670           0 :         sparsetrsv(&a2, isupper, ae_false, 1, x, _state);
   12671           0 :         sparsetrsv(&a2, isupper, ae_false, 0, x, _state);
   12672             :     }
   12673             :     else
   12674             :     {
   12675           0 :         sparsetrsv(&a2, isupper, ae_false, 0, x, _state);
   12676           0 :         sparsetrsv(&a2, isupper, ae_false, 1, x, _state);
   12677             :     }
   12678           0 :     for(i=n-1; i>=0; i--)
   12679             :     {
   12680           0 :         j = p.ptr.p_int[i];
   12681           0 :         v = x->ptr.p_double[i];
   12682           0 :         x->ptr.p_double[i] = x->ptr.p_double[j];
   12683           0 :         x->ptr.p_double[j] = v;
   12684             :     }
   12685           0 :     rep->terminationtype = 1;
   12686           0 :     ae_frame_leave(_state);
   12687             : }
   12688             : 
   12689             : 
   12690             : /*************************************************************************
   12691             : Sparse linear solver for A*x=b with N*N real  symmetric  positive definite
   12692             : matrix A given by its Cholesky decomposition, and N*1 vectors x and b.
   12693             : 
   12694             : IMPORTANT: this solver requires input matrix to be in  the  SKS  (Skyline)
   12695             :            or CRS (compressed row storage) format. An  exception  will  be
   12696             :            generated if you pass matrix in some other format.
   12697             : 
   12698             : INPUT PARAMETERS
   12699             :     A       -   sparse NxN matrix stored in CRs or SKS format, must be NxN
   12700             :                 exactly
   12701             :     IsUpper -   which half of A is provided (another half is ignored)
   12702             :     B       -   array[N], right part
   12703             : 
   12704             : OUTPUT PARAMETERS
   12705             :     X       -   array[N], it contains:
   12706             :                 * rep.terminationtype>0    =>  solution
   12707             :                 * rep.terminationtype=-3   =>  filled by zeros
   12708             :     Rep     -   solver report, following fields are set:
   12709             :                 * rep.terminationtype - solver status; >0 for success,
   12710             :                   set to -3 on failure (degenerate or non-SPD system).
   12711             : 
   12712             :   -- ALGLIB --
   12713             :      Copyright 26.12.2017 by Bochkanov Sergey
   12714             : *************************************************************************/
   12715           0 : void sparsespdcholeskysolve(sparsematrix* a,
   12716             :      ae_bool isupper,
   12717             :      /* Real    */ ae_vector* b,
   12718             :      /* Real    */ ae_vector* x,
   12719             :      sparsesolverreport* rep,
   12720             :      ae_state *_state)
   12721             : {
   12722             :     ae_int_t i;
   12723             :     ae_int_t n;
   12724             : 
   12725           0 :     ae_vector_clear(x);
   12726           0 :     _sparsesolverreport_clear(rep);
   12727             : 
   12728           0 :     n = sparsegetnrows(a, _state);
   12729           0 :     ae_assert(n>0, "SparseSPDCholeskySolve: N<=0", _state);
   12730           0 :     ae_assert(sparsegetnrows(a, _state)==n, "SparseSPDCholeskySolve: rows(A)!=N", _state);
   12731           0 :     ae_assert(sparsegetncols(a, _state)==n, "SparseSPDCholeskySolve: cols(A)!=N", _state);
   12732           0 :     ae_assert(sparseissks(a, _state)||sparseiscrs(a, _state), "SparseSPDCholeskySolve: A is not an SKS/CRS matrix", _state);
   12733           0 :     ae_assert(b->cnt>=n, "SparseSPDCholeskySolve: length(B)<N", _state);
   12734           0 :     ae_assert(isfinitevector(b, n, _state), "SparseSPDCholeskySolve: B contains infinities or NANs", _state);
   12735           0 :     directsparsesolvers_initreport(rep, _state);
   12736           0 :     ae_vector_set_length(x, n, _state);
   12737           0 :     for(i=0; i<=n-1; i++)
   12738             :     {
   12739           0 :         if( ae_fp_eq(sparseget(a, i, i, _state),0.0) )
   12740             :         {
   12741           0 :             rep->terminationtype = -3;
   12742           0 :             for(i=0; i<=n-1; i++)
   12743             :             {
   12744           0 :                 x->ptr.p_double[i] = (double)(0);
   12745             :             }
   12746           0 :             return;
   12747             :         }
   12748             :     }
   12749           0 :     for(i=0; i<=n-1; i++)
   12750             :     {
   12751           0 :         x->ptr.p_double[i] = b->ptr.p_double[i];
   12752             :     }
   12753           0 :     if( isupper )
   12754             :     {
   12755           0 :         sparsetrsv(a, isupper, ae_false, 1, x, _state);
   12756           0 :         sparsetrsv(a, isupper, ae_false, 0, x, _state);
   12757             :     }
   12758             :     else
   12759             :     {
   12760           0 :         sparsetrsv(a, isupper, ae_false, 0, x, _state);
   12761           0 :         sparsetrsv(a, isupper, ae_false, 1, x, _state);
   12762             :     }
   12763           0 :     rep->terminationtype = 1;
   12764             : }
   12765             : 
   12766             : 
   12767             : /*************************************************************************
   12768             : Sparse linear solver for A*x=b with general (nonsymmetric) N*N sparse real
   12769             : matrix A, N*1 vectors x and b.
   12770             : 
   12771             : This solver converts input matrix to CRS format, performs LU factorization
   12772             : and uses sparse triangular solvers to get solution of the original system.
   12773             : 
   12774             : INPUT PARAMETERS
   12775             :     A       -   sparse matrix, must be NxN exactly, any storage format
   12776             :     N       -   size of A, N>0
   12777             :     B       -   array[0..N-1], right part
   12778             : 
   12779             : OUTPUT PARAMETERS
   12780             :     X       -   array[N], it contains:
   12781             :                 * rep.terminationtype>0    =>  solution
   12782             :                 * rep.terminationtype=-3   =>  filled by zeros
   12783             :     Rep     -   solver report, following fields are set:
   12784             :                 * rep.terminationtype - solver status; >0 for success,
   12785             :                   set to -3 on failure (degenerate system).
   12786             : 
   12787             :   -- ALGLIB --
   12788             :      Copyright 26.12.2017 by Bochkanov Sergey
   12789             : *************************************************************************/
   12790           0 : void sparsesolve(sparsematrix* a,
   12791             :      /* Real    */ ae_vector* b,
   12792             :      /* Real    */ ae_vector* x,
   12793             :      sparsesolverreport* rep,
   12794             :      ae_state *_state)
   12795             : {
   12796             :     ae_frame _frame_block;
   12797             :     ae_int_t i;
   12798             :     ae_int_t j;
   12799             :     ae_int_t n;
   12800             :     double v;
   12801             :     sparsematrix a2;
   12802             :     ae_vector pivp;
   12803             :     ae_vector pivq;
   12804             : 
   12805           0 :     ae_frame_make(_state, &_frame_block);
   12806           0 :     memset(&a2, 0, sizeof(a2));
   12807           0 :     memset(&pivp, 0, sizeof(pivp));
   12808           0 :     memset(&pivq, 0, sizeof(pivq));
   12809           0 :     ae_vector_clear(x);
   12810           0 :     _sparsesolverreport_clear(rep);
   12811           0 :     _sparsematrix_init(&a2, _state, ae_true);
   12812           0 :     ae_vector_init(&pivp, 0, DT_INT, _state, ae_true);
   12813           0 :     ae_vector_init(&pivq, 0, DT_INT, _state, ae_true);
   12814             : 
   12815           0 :     n = sparsegetnrows(a, _state);
   12816           0 :     ae_assert(n>0, "SparseSolve: N<=0", _state);
   12817           0 :     ae_assert(sparsegetnrows(a, _state)==n, "SparseSolve: rows(A)!=N", _state);
   12818           0 :     ae_assert(sparsegetncols(a, _state)==n, "SparseSolve: cols(A)!=N", _state);
   12819           0 :     ae_assert(b->cnt>=n, "SparseSolve: length(B)<N", _state);
   12820           0 :     ae_assert(isfinitevector(b, n, _state), "SparseSolve: B contains infinities or NANs", _state);
   12821           0 :     directsparsesolvers_initreport(rep, _state);
   12822           0 :     ae_vector_set_length(x, n, _state);
   12823           0 :     sparsecopytocrs(a, &a2, _state);
   12824           0 :     if( !sparselu(&a2, 0, &pivp, &pivq, _state) )
   12825             :     {
   12826           0 :         rep->terminationtype = -3;
   12827           0 :         for(i=0; i<=n-1; i++)
   12828             :         {
   12829           0 :             x->ptr.p_double[i] = (double)(0);
   12830             :         }
   12831           0 :         ae_frame_leave(_state);
   12832           0 :         return;
   12833             :     }
   12834           0 :     for(i=0; i<=n-1; i++)
   12835             :     {
   12836           0 :         x->ptr.p_double[i] = b->ptr.p_double[i];
   12837             :     }
   12838           0 :     for(i=0; i<=n-1; i++)
   12839             :     {
   12840           0 :         j = pivp.ptr.p_int[i];
   12841           0 :         v = x->ptr.p_double[i];
   12842           0 :         x->ptr.p_double[i] = x->ptr.p_double[j];
   12843           0 :         x->ptr.p_double[j] = v;
   12844             :     }
   12845           0 :     sparsetrsv(&a2, ae_false, ae_true, 0, x, _state);
   12846           0 :     sparsetrsv(&a2, ae_true, ae_false, 0, x, _state);
   12847           0 :     for(i=n-1; i>=0; i--)
   12848             :     {
   12849           0 :         j = pivq.ptr.p_int[i];
   12850           0 :         v = x->ptr.p_double[i];
   12851           0 :         x->ptr.p_double[i] = x->ptr.p_double[j];
   12852           0 :         x->ptr.p_double[j] = v;
   12853             :     }
   12854           0 :     rep->terminationtype = 1;
   12855           0 :     ae_frame_leave(_state);
   12856             : }
   12857             : 
   12858             : 
   12859             : /*************************************************************************
   12860             : Sparse linear solver for A*x=b with general (nonsymmetric) N*N sparse real
   12861             : matrix A given by its LU factorization, N*1 vectors x and b.
   12862             : 
   12863             : IMPORTANT: this solver requires input matrix  to  be  in  the  CRS  sparse
   12864             :            storage format. An exception will  be  generated  if  you  pass
   12865             :            matrix in some other format (HASH or SKS).
   12866             : 
   12867             : INPUT PARAMETERS
   12868             :     A       -   LU factorization of the sparse matrix, must be NxN exactly
   12869             :                 in CRS storage format
   12870             :     P, Q    -   pivot indexes from LU factorization
   12871             :     N       -   size of A, N>0
   12872             :     B       -   array[0..N-1], right part
   12873             : 
   12874             : OUTPUT PARAMETERS
   12875             :     X       -   array[N], it contains:
   12876             :                 * rep.terminationtype>0    =>  solution
   12877             :                 * rep.terminationtype=-3   =>  filled by zeros
   12878             :     Rep     -   solver report, following fields are set:
   12879             :                 * rep.terminationtype - solver status; >0 for success,
   12880             :                   set to -3 on failure (degenerate system).
   12881             : 
   12882             :   -- ALGLIB --
   12883             :      Copyright 26.12.2017 by Bochkanov Sergey
   12884             : *************************************************************************/
   12885           0 : void sparselusolve(sparsematrix* a,
   12886             :      /* Integer */ ae_vector* p,
   12887             :      /* Integer */ ae_vector* q,
   12888             :      /* Real    */ ae_vector* b,
   12889             :      /* Real    */ ae_vector* x,
   12890             :      sparsesolverreport* rep,
   12891             :      ae_state *_state)
   12892             : {
   12893             :     ae_int_t i;
   12894             :     ae_int_t j;
   12895             :     double v;
   12896             :     ae_int_t n;
   12897             : 
   12898           0 :     ae_vector_clear(x);
   12899           0 :     _sparsesolverreport_clear(rep);
   12900             : 
   12901           0 :     n = sparsegetnrows(a, _state);
   12902           0 :     ae_assert(n>0, "SparseLUSolve: N<=0", _state);
   12903           0 :     ae_assert(sparsegetnrows(a, _state)==n, "SparseLUSolve: rows(A)!=N", _state);
   12904           0 :     ae_assert(sparsegetncols(a, _state)==n, "SparseLUSolve: cols(A)!=N", _state);
   12905           0 :     ae_assert(sparseiscrs(a, _state), "SparseLUSolve: A is not an SKS matrix", _state);
   12906           0 :     ae_assert(b->cnt>=n, "SparseLUSolve: length(B)<N", _state);
   12907           0 :     ae_assert(isfinitevector(b, n, _state), "SparseLUSolve: B contains infinities or NANs", _state);
   12908           0 :     ae_assert(p->cnt>=n, "SparseLUSolve: length(P)<N", _state);
   12909           0 :     ae_assert(q->cnt>=n, "SparseLUSolve: length(Q)<N", _state);
   12910           0 :     for(i=0; i<=n-1; i++)
   12911             :     {
   12912           0 :         ae_assert(p->ptr.p_int[i]>=i&&p->ptr.p_int[i]<n, "SparseLUSolve: P is corrupted", _state);
   12913           0 :         ae_assert(q->ptr.p_int[i]>=i&&q->ptr.p_int[i]<n, "SparseLUSolve: Q is corrupted", _state);
   12914             :     }
   12915           0 :     directsparsesolvers_initreport(rep, _state);
   12916           0 :     ae_vector_set_length(x, n, _state);
   12917           0 :     for(i=0; i<=n-1; i++)
   12918             :     {
   12919           0 :         if( a->didx.ptr.p_int[i]==a->uidx.ptr.p_int[i]||a->vals.ptr.p_double[a->didx.ptr.p_int[i]]==0.0 )
   12920             :         {
   12921           0 :             rep->terminationtype = -3;
   12922           0 :             for(i=0; i<=n-1; i++)
   12923             :             {
   12924           0 :                 x->ptr.p_double[i] = (double)(0);
   12925             :             }
   12926           0 :             return;
   12927             :         }
   12928             :     }
   12929           0 :     for(i=0; i<=n-1; i++)
   12930             :     {
   12931           0 :         x->ptr.p_double[i] = b->ptr.p_double[i];
   12932             :     }
   12933           0 :     for(i=0; i<=n-1; i++)
   12934             :     {
   12935           0 :         j = p->ptr.p_int[i];
   12936           0 :         v = x->ptr.p_double[i];
   12937           0 :         x->ptr.p_double[i] = x->ptr.p_double[j];
   12938           0 :         x->ptr.p_double[j] = v;
   12939             :     }
   12940           0 :     sparsetrsv(a, ae_false, ae_true, 0, x, _state);
   12941           0 :     sparsetrsv(a, ae_true, ae_false, 0, x, _state);
   12942           0 :     for(i=n-1; i>=0; i--)
   12943             :     {
   12944           0 :         j = q->ptr.p_int[i];
   12945           0 :         v = x->ptr.p_double[i];
   12946           0 :         x->ptr.p_double[i] = x->ptr.p_double[j];
   12947           0 :         x->ptr.p_double[j] = v;
   12948             :     }
   12949           0 :     rep->terminationtype = 1;
   12950             : }
   12951             : 
   12952             : 
   12953             : /*************************************************************************
   12954             : Reset report fields
   12955             : 
   12956             :   -- ALGLIB --
   12957             :      Copyright 26.12.2017 by Bochkanov Sergey
   12958             : *************************************************************************/
   12959           0 : static void directsparsesolvers_initreport(sparsesolverreport* rep,
   12960             :      ae_state *_state)
   12961             : {
   12962             : 
   12963           0 :     _sparsesolverreport_clear(rep);
   12964             : 
   12965           0 :     rep->terminationtype = 0;
   12966           0 : }
   12967             : 
   12968             : 
   12969           0 : void _sparsesolverreport_init(void* _p, ae_state *_state, ae_bool make_automatic)
   12970             : {
   12971           0 :     sparsesolverreport *p = (sparsesolverreport*)_p;
   12972           0 :     ae_touch_ptr((void*)p);
   12973           0 : }
   12974             : 
   12975             : 
   12976           0 : void _sparsesolverreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   12977             : {
   12978           0 :     sparsesolverreport *dst = (sparsesolverreport*)_dst;
   12979           0 :     sparsesolverreport *src = (sparsesolverreport*)_src;
   12980           0 :     dst->terminationtype = src->terminationtype;
   12981           0 : }
   12982             : 
   12983             : 
   12984           0 : void _sparsesolverreport_clear(void* _p)
   12985             : {
   12986           0 :     sparsesolverreport *p = (sparsesolverreport*)_p;
   12987           0 :     ae_touch_ptr((void*)p);
   12988           0 : }
   12989             : 
   12990             : 
   12991           0 : void _sparsesolverreport_destroy(void* _p)
   12992             : {
   12993           0 :     sparsesolverreport *p = (sparsesolverreport*)_p;
   12994           0 :     ae_touch_ptr((void*)p);
   12995           0 : }
   12996             : 
   12997             : 
   12998             : #endif
   12999             : #if defined(AE_COMPILE_LINCG) || !defined(AE_PARTIAL_BUILD)
   13000             : 
   13001             : 
   13002             : /*************************************************************************
   13003             : This function initializes linear CG Solver. This solver is used  to  solve
   13004             : symmetric positive definite problems. If you want  to  solve  nonsymmetric
   13005             : (or non-positive definite) problem you may use LinLSQR solver provided  by
   13006             : ALGLIB.
   13007             : 
   13008             : USAGE:
   13009             : 1. User initializes algorithm state with LinCGCreate() call
   13010             : 2. User tunes solver parameters with  LinCGSetCond() and other functions
   13011             : 3. Optionally, user sets starting point with LinCGSetStartingPoint()
   13012             : 4. User  calls LinCGSolveSparse() function which takes algorithm state and
   13013             :    SparseMatrix object.
   13014             : 5. User calls LinCGResults() to get solution
   13015             : 6. Optionally, user may call LinCGSolveSparse()  again  to  solve  another
   13016             :    problem  with different matrix and/or right part without reinitializing
   13017             :    LinCGState structure.
   13018             :   
   13019             : INPUT PARAMETERS:
   13020             :     N       -   problem dimension, N>0
   13021             : 
   13022             : OUTPUT PARAMETERS:
   13023             :     State   -   structure which stores algorithm state
   13024             : 
   13025             :   -- ALGLIB --
   13026             :      Copyright 14.11.2011 by Bochkanov Sergey
   13027             : *************************************************************************/
   13028           0 : void lincgcreate(ae_int_t n, lincgstate* state, ae_state *_state)
   13029             : {
   13030             :     ae_int_t i;
   13031             : 
   13032           0 :     _lincgstate_clear(state);
   13033             : 
   13034           0 :     ae_assert(n>0, "LinCGCreate: N<=0", _state);
   13035           0 :     state->n = n;
   13036           0 :     state->prectype = 0;
   13037           0 :     state->itsbeforerestart = n;
   13038           0 :     state->itsbeforerupdate = 10;
   13039           0 :     state->epsf = lincg_defaultprecision;
   13040           0 :     state->maxits = 0;
   13041           0 :     state->xrep = ae_false;
   13042           0 :     state->running = ae_false;
   13043             :     
   13044             :     /*
   13045             :      * * allocate arrays
   13046             :      * * set RX to NAN (just for the case user calls Results() without 
   13047             :      *   calling SolveSparse()
   13048             :      * * set starting point to zero
   13049             :      * * we do NOT initialize B here because we assume that user should
   13050             :      *   initializate it using LinCGSetB() function. In case he forgets
   13051             :      *   to do so, exception will be thrown in the LinCGIteration().
   13052             :      */
   13053           0 :     ae_vector_set_length(&state->rx, state->n, _state);
   13054           0 :     ae_vector_set_length(&state->startx, state->n, _state);
   13055           0 :     ae_vector_set_length(&state->b, state->n, _state);
   13056           0 :     for(i=0; i<=state->n-1; i++)
   13057             :     {
   13058           0 :         state->rx.ptr.p_double[i] = _state->v_nan;
   13059           0 :         state->startx.ptr.p_double[i] = 0.0;
   13060           0 :         state->b.ptr.p_double[i] = (double)(0);
   13061             :     }
   13062           0 :     ae_vector_set_length(&state->cx, state->n, _state);
   13063           0 :     ae_vector_set_length(&state->p, state->n, _state);
   13064           0 :     ae_vector_set_length(&state->r, state->n, _state);
   13065           0 :     ae_vector_set_length(&state->cr, state->n, _state);
   13066           0 :     ae_vector_set_length(&state->z, state->n, _state);
   13067           0 :     ae_vector_set_length(&state->cz, state->n, _state);
   13068           0 :     ae_vector_set_length(&state->x, state->n, _state);
   13069           0 :     ae_vector_set_length(&state->mv, state->n, _state);
   13070           0 :     ae_vector_set_length(&state->pv, state->n, _state);
   13071           0 :     lincg_updateitersdata(state, _state);
   13072           0 :     ae_vector_set_length(&state->rstate.ia, 0+1, _state);
   13073           0 :     ae_vector_set_length(&state->rstate.ra, 2+1, _state);
   13074           0 :     state->rstate.stage = -1;
   13075           0 : }
   13076             : 
   13077             : 
   13078             : /*************************************************************************
   13079             : This function sets starting point.
   13080             : By default, zero starting point is used.
   13081             : 
   13082             : INPUT PARAMETERS:
   13083             :     X       -   starting point, array[N]
   13084             : 
   13085             : OUTPUT PARAMETERS:
   13086             :     State   -   structure which stores algorithm state
   13087             : 
   13088             :   -- ALGLIB --
   13089             :      Copyright 14.11.2011 by Bochkanov Sergey
   13090             : *************************************************************************/
   13091           0 : void lincgsetstartingpoint(lincgstate* state,
   13092             :      /* Real    */ ae_vector* x,
   13093             :      ae_state *_state)
   13094             : {
   13095             : 
   13096             : 
   13097           0 :     ae_assert(!state->running, "LinCGSetStartingPoint: you can not change starting point because LinCGIteration() function is running", _state);
   13098           0 :     ae_assert(state->n<=x->cnt, "LinCGSetStartingPoint: Length(X)<N", _state);
   13099           0 :     ae_assert(isfinitevector(x, state->n, _state), "LinCGSetStartingPoint: X contains infinite or NaN values!", _state);
   13100           0 :     ae_v_move(&state->startx.ptr.p_double[0], 1, &x->ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13101           0 : }
   13102             : 
   13103             : 
   13104             : /*************************************************************************
   13105             : This function sets right part. By default, right part is zero.
   13106             : 
   13107             : INPUT PARAMETERS:
   13108             :     B       -   right part, array[N].
   13109             : 
   13110             : OUTPUT PARAMETERS:
   13111             :     State   -   structure which stores algorithm state
   13112             : 
   13113             :   -- ALGLIB --
   13114             :      Copyright 14.11.2011 by Bochkanov Sergey
   13115             : *************************************************************************/
   13116           0 : void lincgsetb(lincgstate* state,
   13117             :      /* Real    */ ae_vector* b,
   13118             :      ae_state *_state)
   13119             : {
   13120             : 
   13121             : 
   13122           0 :     ae_assert(!state->running, "LinCGSetB: you can not set B, because function LinCGIteration is running!", _state);
   13123           0 :     ae_assert(b->cnt>=state->n, "LinCGSetB: Length(B)<N", _state);
   13124           0 :     ae_assert(isfinitevector(b, state->n, _state), "LinCGSetB: B contains infinite or NaN values!", _state);
   13125           0 :     ae_v_move(&state->b.ptr.p_double[0], 1, &b->ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13126           0 : }
   13127             : 
   13128             : 
   13129             : /*************************************************************************
   13130             : This  function  changes  preconditioning  settings  of  LinCGSolveSparse()
   13131             : function. By default, SolveSparse() uses diagonal preconditioner,  but  if
   13132             : you want to use solver without preconditioning, you can call this function
   13133             : which forces solver to use unit matrix for preconditioning.
   13134             : 
   13135             : INPUT PARAMETERS:
   13136             :     State   -   structure which stores algorithm state
   13137             : 
   13138             :   -- ALGLIB --
   13139             :      Copyright 19.11.2012 by Bochkanov Sergey
   13140             : *************************************************************************/
   13141           0 : void lincgsetprecunit(lincgstate* state, ae_state *_state)
   13142             : {
   13143             : 
   13144             : 
   13145           0 :     ae_assert(!state->running, "LinCGSetPrecUnit: you can not change preconditioner, because function LinCGIteration is running!", _state);
   13146           0 :     state->prectype = -1;
   13147           0 : }
   13148             : 
   13149             : 
   13150             : /*************************************************************************
   13151             : This  function  changes  preconditioning  settings  of  LinCGSolveSparse()
   13152             : function.  LinCGSolveSparse() will use diagonal of the  system  matrix  as
   13153             : preconditioner. This preconditioning mode is active by default.
   13154             : 
   13155             : INPUT PARAMETERS:
   13156             :     State   -   structure which stores algorithm state
   13157             : 
   13158             :   -- ALGLIB --
   13159             :      Copyright 19.11.2012 by Bochkanov Sergey
   13160             : *************************************************************************/
   13161           0 : void lincgsetprecdiag(lincgstate* state, ae_state *_state)
   13162             : {
   13163             : 
   13164             : 
   13165           0 :     ae_assert(!state->running, "LinCGSetPrecDiag: you can not change preconditioner, because function LinCGIteration is running!", _state);
   13166           0 :     state->prectype = 0;
   13167           0 : }
   13168             : 
   13169             : 
   13170             : /*************************************************************************
   13171             : This function sets stopping criteria.
   13172             : 
   13173             : INPUT PARAMETERS:
   13174             :     EpsF    -   algorithm will be stopped if norm of residual is less than 
   13175             :                 EpsF*||b||.
   13176             :     MaxIts  -   algorithm will be stopped if number of iterations is  more 
   13177             :                 than MaxIts.
   13178             : 
   13179             : OUTPUT PARAMETERS:
   13180             :     State   -   structure which stores algorithm state
   13181             : 
   13182             : NOTES:
   13183             : If  both  EpsF  and  MaxIts  are  zero then small EpsF will be set to small 
   13184             : value.
   13185             : 
   13186             :   -- ALGLIB --
   13187             :      Copyright 14.11.2011 by Bochkanov Sergey
   13188             : *************************************************************************/
   13189           0 : void lincgsetcond(lincgstate* state,
   13190             :      double epsf,
   13191             :      ae_int_t maxits,
   13192             :      ae_state *_state)
   13193             : {
   13194             : 
   13195             : 
   13196           0 :     ae_assert(!state->running, "LinCGSetCond: you can not change stopping criteria when LinCGIteration() is running", _state);
   13197           0 :     ae_assert(ae_isfinite(epsf, _state)&&ae_fp_greater_eq(epsf,(double)(0)), "LinCGSetCond: EpsF is negative or contains infinite or NaN values", _state);
   13198           0 :     ae_assert(maxits>=0, "LinCGSetCond: MaxIts is negative", _state);
   13199           0 :     if( ae_fp_eq(epsf,(double)(0))&&maxits==0 )
   13200             :     {
   13201           0 :         state->epsf = lincg_defaultprecision;
   13202           0 :         state->maxits = maxits;
   13203             :     }
   13204             :     else
   13205             :     {
   13206           0 :         state->epsf = epsf;
   13207           0 :         state->maxits = maxits;
   13208             :     }
   13209           0 : }
   13210             : 
   13211             : 
   13212             : /*************************************************************************
   13213             : Reverse communication version of linear CG.
   13214             : 
   13215             :   -- ALGLIB --
   13216             :      Copyright 14.11.2011 by Bochkanov Sergey
   13217             : *************************************************************************/
   13218           0 : ae_bool lincgiteration(lincgstate* state, ae_state *_state)
   13219             : {
   13220             :     ae_int_t i;
   13221             :     double uvar;
   13222             :     double bnorm;
   13223             :     double v;
   13224             :     ae_bool result;
   13225             : 
   13226             : 
   13227             :     
   13228             :     /*
   13229             :      * Reverse communication preparations
   13230             :      * I know it looks ugly, but it works the same way
   13231             :      * anywhere from C++ to Python.
   13232             :      *
   13233             :      * This code initializes locals by:
   13234             :      * * random values determined during code
   13235             :      *   generation - on first subroutine call
   13236             :      * * values from previous call - on subsequent calls
   13237             :      */
   13238           0 :     if( state->rstate.stage>=0 )
   13239             :     {
   13240           0 :         i = state->rstate.ia.ptr.p_int[0];
   13241           0 :         uvar = state->rstate.ra.ptr.p_double[0];
   13242           0 :         bnorm = state->rstate.ra.ptr.p_double[1];
   13243           0 :         v = state->rstate.ra.ptr.p_double[2];
   13244             :     }
   13245             :     else
   13246             :     {
   13247           0 :         i = 359;
   13248           0 :         uvar = -58;
   13249           0 :         bnorm = -919;
   13250           0 :         v = -909;
   13251             :     }
   13252           0 :     if( state->rstate.stage==0 )
   13253             :     {
   13254           0 :         goto lbl_0;
   13255             :     }
   13256           0 :     if( state->rstate.stage==1 )
   13257             :     {
   13258           0 :         goto lbl_1;
   13259             :     }
   13260           0 :     if( state->rstate.stage==2 )
   13261             :     {
   13262           0 :         goto lbl_2;
   13263             :     }
   13264           0 :     if( state->rstate.stage==3 )
   13265             :     {
   13266           0 :         goto lbl_3;
   13267             :     }
   13268           0 :     if( state->rstate.stage==4 )
   13269             :     {
   13270           0 :         goto lbl_4;
   13271             :     }
   13272           0 :     if( state->rstate.stage==5 )
   13273             :     {
   13274           0 :         goto lbl_5;
   13275             :     }
   13276           0 :     if( state->rstate.stage==6 )
   13277             :     {
   13278           0 :         goto lbl_6;
   13279             :     }
   13280           0 :     if( state->rstate.stage==7 )
   13281             :     {
   13282           0 :         goto lbl_7;
   13283             :     }
   13284             :     
   13285             :     /*
   13286             :      * Routine body
   13287             :      */
   13288           0 :     ae_assert(state->b.cnt>0, "LinCGIteration: B is not initialized (you must initialize B by LinCGSetB() call", _state);
   13289           0 :     state->running = ae_true;
   13290           0 :     state->repnmv = 0;
   13291           0 :     lincg_clearrfields(state, _state);
   13292           0 :     lincg_updateitersdata(state, _state);
   13293             :     
   13294             :     /*
   13295             :      * Start 0-th iteration
   13296             :      */
   13297           0 :     ae_v_move(&state->rx.ptr.p_double[0], 1, &state->startx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13298           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13299           0 :     state->repnmv = state->repnmv+1;
   13300           0 :     lincg_clearrfields(state, _state);
   13301           0 :     state->needvmv = ae_true;
   13302           0 :     state->rstate.stage = 0;
   13303           0 :     goto lbl_rcomm;
   13304           0 : lbl_0:
   13305           0 :     state->needvmv = ae_false;
   13306           0 :     bnorm = (double)(0);
   13307           0 :     state->r2 = (double)(0);
   13308           0 :     state->meritfunction = (double)(0);
   13309           0 :     for(i=0; i<=state->n-1; i++)
   13310             :     {
   13311           0 :         state->r.ptr.p_double[i] = state->b.ptr.p_double[i]-state->mv.ptr.p_double[i];
   13312           0 :         state->r2 = state->r2+state->r.ptr.p_double[i]*state->r.ptr.p_double[i];
   13313           0 :         state->meritfunction = state->meritfunction+state->mv.ptr.p_double[i]*state->rx.ptr.p_double[i]-2*state->b.ptr.p_double[i]*state->rx.ptr.p_double[i];
   13314           0 :         bnorm = bnorm+state->b.ptr.p_double[i]*state->b.ptr.p_double[i];
   13315             :     }
   13316           0 :     bnorm = ae_sqrt(bnorm, _state);
   13317             :     
   13318             :     /*
   13319             :      * Output first report
   13320             :      */
   13321           0 :     if( !state->xrep )
   13322             :     {
   13323           0 :         goto lbl_8;
   13324             :     }
   13325           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13326           0 :     lincg_clearrfields(state, _state);
   13327           0 :     state->xupdated = ae_true;
   13328           0 :     state->rstate.stage = 1;
   13329           0 :     goto lbl_rcomm;
   13330           0 : lbl_1:
   13331           0 :     state->xupdated = ae_false;
   13332           0 : lbl_8:
   13333             :     
   13334             :     /*
   13335             :      * Is x0 a solution?
   13336             :      */
   13337           0 :     if( !ae_isfinite(state->r2, _state)||ae_fp_less_eq(ae_sqrt(state->r2, _state),state->epsf*bnorm) )
   13338             :     {
   13339           0 :         state->running = ae_false;
   13340           0 :         if( ae_isfinite(state->r2, _state) )
   13341             :         {
   13342           0 :             state->repterminationtype = 1;
   13343             :         }
   13344             :         else
   13345             :         {
   13346           0 :             state->repterminationtype = -4;
   13347             :         }
   13348           0 :         result = ae_false;
   13349           0 :         return result;
   13350             :     }
   13351             :     
   13352             :     /*
   13353             :      * Calculate Z and P
   13354             :      */
   13355           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->r.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13356           0 :     state->repnmv = state->repnmv+1;
   13357           0 :     lincg_clearrfields(state, _state);
   13358           0 :     state->needprec = ae_true;
   13359           0 :     state->rstate.stage = 2;
   13360           0 :     goto lbl_rcomm;
   13361           0 : lbl_2:
   13362           0 :     state->needprec = ae_false;
   13363           0 :     for(i=0; i<=state->n-1; i++)
   13364             :     {
   13365           0 :         state->z.ptr.p_double[i] = state->pv.ptr.p_double[i];
   13366           0 :         state->p.ptr.p_double[i] = state->z.ptr.p_double[i];
   13367             :     }
   13368             :     
   13369             :     /*
   13370             :      * Other iterations(1..N)
   13371             :      */
   13372           0 :     state->repiterationscount = 0;
   13373           0 : lbl_10:
   13374             :     if( ae_false )
   13375             :     {
   13376             :         goto lbl_11;
   13377             :     }
   13378           0 :     state->repiterationscount = state->repiterationscount+1;
   13379             :     
   13380             :     /*
   13381             :      * Calculate Alpha
   13382             :      */
   13383           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->p.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13384           0 :     state->repnmv = state->repnmv+1;
   13385           0 :     lincg_clearrfields(state, _state);
   13386           0 :     state->needvmv = ae_true;
   13387           0 :     state->rstate.stage = 3;
   13388           0 :     goto lbl_rcomm;
   13389           0 : lbl_3:
   13390           0 :     state->needvmv = ae_false;
   13391           0 :     if( !ae_isfinite(state->vmv, _state)||ae_fp_less_eq(state->vmv,(double)(0)) )
   13392             :     {
   13393             :         
   13394             :         /*
   13395             :          * a) Overflow when calculating VMV
   13396             :          * b) non-positive VMV (non-SPD matrix)
   13397             :          */
   13398           0 :         state->running = ae_false;
   13399           0 :         if( ae_isfinite(state->vmv, _state) )
   13400             :         {
   13401           0 :             state->repterminationtype = -5;
   13402             :         }
   13403             :         else
   13404             :         {
   13405           0 :             state->repterminationtype = -4;
   13406             :         }
   13407           0 :         result = ae_false;
   13408           0 :         return result;
   13409             :     }
   13410           0 :     state->alpha = (double)(0);
   13411           0 :     for(i=0; i<=state->n-1; i++)
   13412             :     {
   13413           0 :         state->alpha = state->alpha+state->r.ptr.p_double[i]*state->z.ptr.p_double[i];
   13414             :     }
   13415           0 :     state->alpha = state->alpha/state->vmv;
   13416           0 :     if( !ae_isfinite(state->alpha, _state) )
   13417             :     {
   13418             :         
   13419             :         /*
   13420             :          * Overflow when calculating Alpha
   13421             :          */
   13422           0 :         state->running = ae_false;
   13423           0 :         state->repterminationtype = -4;
   13424           0 :         result = ae_false;
   13425           0 :         return result;
   13426             :     }
   13427             :     
   13428             :     /*
   13429             :      * Next step toward solution
   13430             :      */
   13431           0 :     for(i=0; i<=state->n-1; i++)
   13432             :     {
   13433           0 :         state->cx.ptr.p_double[i] = state->rx.ptr.p_double[i]+state->alpha*state->p.ptr.p_double[i];
   13434             :     }
   13435             :     
   13436             :     /*
   13437             :      * Calculate R:
   13438             :      * * use recurrent relation to update R
   13439             :      * * at every ItsBeforeRUpdate-th iteration recalculate it from scratch, using matrix-vector product
   13440             :      *   in case R grows instead of decreasing, algorithm is terminated with positive completion code
   13441             :      */
   13442           0 :     if( !(state->itsbeforerupdate==0||state->repiterationscount%state->itsbeforerupdate!=0) )
   13443             :     {
   13444           0 :         goto lbl_12;
   13445             :     }
   13446             :     
   13447             :     /*
   13448             :      * Calculate R using recurrent formula
   13449             :      */
   13450           0 :     for(i=0; i<=state->n-1; i++)
   13451             :     {
   13452           0 :         state->cr.ptr.p_double[i] = state->r.ptr.p_double[i]-state->alpha*state->mv.ptr.p_double[i];
   13453           0 :         state->x.ptr.p_double[i] = state->cr.ptr.p_double[i];
   13454             :     }
   13455           0 :     goto lbl_13;
   13456           0 : lbl_12:
   13457             :     
   13458             :     /*
   13459             :      * Calculate R using matrix-vector multiplication
   13460             :      */
   13461           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->cx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13462           0 :     state->repnmv = state->repnmv+1;
   13463           0 :     lincg_clearrfields(state, _state);
   13464           0 :     state->needmv = ae_true;
   13465           0 :     state->rstate.stage = 4;
   13466           0 :     goto lbl_rcomm;
   13467           0 : lbl_4:
   13468           0 :     state->needmv = ae_false;
   13469           0 :     for(i=0; i<=state->n-1; i++)
   13470             :     {
   13471           0 :         state->cr.ptr.p_double[i] = state->b.ptr.p_double[i]-state->mv.ptr.p_double[i];
   13472           0 :         state->x.ptr.p_double[i] = state->cr.ptr.p_double[i];
   13473             :     }
   13474             :     
   13475             :     /*
   13476             :      * Calculating merit function
   13477             :      * Check emergency stopping criterion
   13478             :      */
   13479           0 :     v = (double)(0);
   13480           0 :     for(i=0; i<=state->n-1; i++)
   13481             :     {
   13482           0 :         v = v+state->mv.ptr.p_double[i]*state->cx.ptr.p_double[i]-2*state->b.ptr.p_double[i]*state->cx.ptr.p_double[i];
   13483             :     }
   13484           0 :     if( ae_fp_less(v,state->meritfunction) )
   13485             :     {
   13486           0 :         goto lbl_14;
   13487             :     }
   13488           0 :     for(i=0; i<=state->n-1; i++)
   13489             :     {
   13490           0 :         if( !ae_isfinite(state->rx.ptr.p_double[i], _state) )
   13491             :         {
   13492           0 :             state->running = ae_false;
   13493           0 :             state->repterminationtype = -4;
   13494           0 :             result = ae_false;
   13495           0 :             return result;
   13496             :         }
   13497             :     }
   13498             :     
   13499             :     /*
   13500             :      *output last report
   13501             :      */
   13502           0 :     if( !state->xrep )
   13503             :     {
   13504           0 :         goto lbl_16;
   13505             :     }
   13506           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13507           0 :     lincg_clearrfields(state, _state);
   13508           0 :     state->xupdated = ae_true;
   13509           0 :     state->rstate.stage = 5;
   13510           0 :     goto lbl_rcomm;
   13511           0 : lbl_5:
   13512           0 :     state->xupdated = ae_false;
   13513           0 : lbl_16:
   13514           0 :     state->running = ae_false;
   13515           0 :     state->repterminationtype = 7;
   13516           0 :     result = ae_false;
   13517           0 :     return result;
   13518           0 : lbl_14:
   13519           0 :     state->meritfunction = v;
   13520           0 : lbl_13:
   13521           0 :     ae_v_move(&state->rx.ptr.p_double[0], 1, &state->cx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13522             :     
   13523             :     /*
   13524             :      * calculating RNorm
   13525             :      *
   13526             :      * NOTE: monotonic decrease of R2 is not guaranteed by algorithm.
   13527             :      */
   13528           0 :     state->r2 = (double)(0);
   13529           0 :     for(i=0; i<=state->n-1; i++)
   13530             :     {
   13531           0 :         state->r2 = state->r2+state->cr.ptr.p_double[i]*state->cr.ptr.p_double[i];
   13532             :     }
   13533             :     
   13534             :     /*
   13535             :      *output report
   13536             :      */
   13537           0 :     if( !state->xrep )
   13538             :     {
   13539           0 :         goto lbl_18;
   13540             :     }
   13541           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13542           0 :     lincg_clearrfields(state, _state);
   13543           0 :     state->xupdated = ae_true;
   13544           0 :     state->rstate.stage = 6;
   13545           0 :     goto lbl_rcomm;
   13546           0 : lbl_6:
   13547           0 :     state->xupdated = ae_false;
   13548           0 : lbl_18:
   13549             :     
   13550             :     /*
   13551             :      *stopping criterion
   13552             :      *achieved the required precision
   13553             :      */
   13554           0 :     if( !ae_isfinite(state->r2, _state)||ae_fp_less_eq(ae_sqrt(state->r2, _state),state->epsf*bnorm) )
   13555             :     {
   13556           0 :         state->running = ae_false;
   13557           0 :         if( ae_isfinite(state->r2, _state) )
   13558             :         {
   13559           0 :             state->repterminationtype = 1;
   13560             :         }
   13561             :         else
   13562             :         {
   13563           0 :             state->repterminationtype = -4;
   13564             :         }
   13565           0 :         result = ae_false;
   13566           0 :         return result;
   13567             :     }
   13568           0 :     if( state->repiterationscount>=state->maxits&&state->maxits>0 )
   13569             :     {
   13570           0 :         for(i=0; i<=state->n-1; i++)
   13571             :         {
   13572           0 :             if( !ae_isfinite(state->rx.ptr.p_double[i], _state) )
   13573             :             {
   13574           0 :                 state->running = ae_false;
   13575           0 :                 state->repterminationtype = -4;
   13576           0 :                 result = ae_false;
   13577           0 :                 return result;
   13578             :             }
   13579             :         }
   13580             :         
   13581             :         /*
   13582             :          *if X is finite number
   13583             :          */
   13584           0 :         state->running = ae_false;
   13585           0 :         state->repterminationtype = 5;
   13586           0 :         result = ae_false;
   13587           0 :         return result;
   13588             :     }
   13589           0 :     ae_v_move(&state->x.ptr.p_double[0], 1, &state->cr.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13590             :     
   13591             :     /*
   13592             :      *prepere of parameters for next iteration
   13593             :      */
   13594           0 :     state->repnmv = state->repnmv+1;
   13595           0 :     lincg_clearrfields(state, _state);
   13596           0 :     state->needprec = ae_true;
   13597           0 :     state->rstate.stage = 7;
   13598           0 :     goto lbl_rcomm;
   13599           0 : lbl_7:
   13600           0 :     state->needprec = ae_false;
   13601           0 :     ae_v_move(&state->cz.ptr.p_double[0], 1, &state->pv.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13602           0 :     if( state->repiterationscount%state->itsbeforerestart!=0 )
   13603             :     {
   13604           0 :         state->beta = (double)(0);
   13605           0 :         uvar = (double)(0);
   13606           0 :         for(i=0; i<=state->n-1; i++)
   13607             :         {
   13608           0 :             state->beta = state->beta+state->cz.ptr.p_double[i]*state->cr.ptr.p_double[i];
   13609           0 :             uvar = uvar+state->z.ptr.p_double[i]*state->r.ptr.p_double[i];
   13610             :         }
   13611             :         
   13612             :         /*
   13613             :          *check that UVar is't INF or is't zero
   13614             :          */
   13615           0 :         if( !ae_isfinite(uvar, _state)||ae_fp_eq(uvar,(double)(0)) )
   13616             :         {
   13617           0 :             state->running = ae_false;
   13618           0 :             state->repterminationtype = -4;
   13619           0 :             result = ae_false;
   13620           0 :             return result;
   13621             :         }
   13622             :         
   13623             :         /*
   13624             :          *calculate .BETA
   13625             :          */
   13626           0 :         state->beta = state->beta/uvar;
   13627             :         
   13628             :         /*
   13629             :          *check that .BETA neither INF nor NaN
   13630             :          */
   13631           0 :         if( !ae_isfinite(state->beta, _state) )
   13632             :         {
   13633           0 :             state->running = ae_false;
   13634           0 :             state->repterminationtype = -1;
   13635           0 :             result = ae_false;
   13636           0 :             return result;
   13637             :         }
   13638           0 :         for(i=0; i<=state->n-1; i++)
   13639             :         {
   13640           0 :             state->p.ptr.p_double[i] = state->cz.ptr.p_double[i]+state->beta*state->p.ptr.p_double[i];
   13641             :         }
   13642             :     }
   13643             :     else
   13644             :     {
   13645           0 :         ae_v_move(&state->p.ptr.p_double[0], 1, &state->cz.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13646             :     }
   13647             :     
   13648             :     /*
   13649             :      *prepere data for next iteration
   13650             :      */
   13651           0 :     for(i=0; i<=state->n-1; i++)
   13652             :     {
   13653             :         
   13654             :         /*
   13655             :          *write (k+1)th iteration to (k )th iteration
   13656             :          */
   13657           0 :         state->r.ptr.p_double[i] = state->cr.ptr.p_double[i];
   13658           0 :         state->z.ptr.p_double[i] = state->cz.ptr.p_double[i];
   13659             :     }
   13660           0 :     goto lbl_10;
   13661             : lbl_11:
   13662             :     result = ae_false;
   13663             :     return result;
   13664             :     
   13665             :     /*
   13666             :      * Saving state
   13667             :      */
   13668           0 : lbl_rcomm:
   13669           0 :     result = ae_true;
   13670           0 :     state->rstate.ia.ptr.p_int[0] = i;
   13671           0 :     state->rstate.ra.ptr.p_double[0] = uvar;
   13672           0 :     state->rstate.ra.ptr.p_double[1] = bnorm;
   13673           0 :     state->rstate.ra.ptr.p_double[2] = v;
   13674           0 :     return result;
   13675             : }
   13676             : 
   13677             : 
   13678             : /*************************************************************************
   13679             : Procedure for solution of A*x=b with sparse A.
   13680             : 
   13681             : INPUT PARAMETERS:
   13682             :     State   -   algorithm state
   13683             :     A       -   sparse matrix in the CRS format (you MUST contvert  it  to 
   13684             :                 CRS format by calling SparseConvertToCRS() function).
   13685             :     IsUpper -   whether upper or lower triangle of A is used:
   13686             :                 * IsUpper=True  => only upper triangle is used and lower
   13687             :                                    triangle is not referenced at all 
   13688             :                 * IsUpper=False => only lower triangle is used and upper
   13689             :                                    triangle is not referenced at all
   13690             :     B       -   right part, array[N]
   13691             : 
   13692             : RESULT:
   13693             :     This function returns no result.
   13694             :     You can get solution by calling LinCGResults()
   13695             :     
   13696             : NOTE: this function uses lightweight preconditioning -  multiplication  by
   13697             :       inverse of diag(A). If you want, you can turn preconditioning off by
   13698             :       calling LinCGSetPrecUnit(). However, preconditioning cost is low and
   13699             :       preconditioner  is  very  important  for  solution  of  badly scaled
   13700             :       problems.
   13701             : 
   13702             :   -- ALGLIB --
   13703             :      Copyright 14.11.2011 by Bochkanov Sergey
   13704             : *************************************************************************/
   13705           0 : void lincgsolvesparse(lincgstate* state,
   13706             :      sparsematrix* a,
   13707             :      ae_bool isupper,
   13708             :      /* Real    */ ae_vector* b,
   13709             :      ae_state *_state)
   13710             : {
   13711             :     ae_int_t n;
   13712             :     ae_int_t i;
   13713             :     double v;
   13714             :     double vmv;
   13715             : 
   13716             : 
   13717           0 :     n = state->n;
   13718           0 :     ae_assert(b->cnt>=state->n, "LinCGSetB: Length(B)<N", _state);
   13719           0 :     ae_assert(isfinitevector(b, state->n, _state), "LinCGSetB: B contains infinite or NaN values!", _state);
   13720             :     
   13721             :     /*
   13722             :      * Allocate temporaries
   13723             :      */
   13724           0 :     rvectorsetlengthatleast(&state->tmpd, n, _state);
   13725             :     
   13726             :     /*
   13727             :      * Compute diagonal scaling matrix D
   13728             :      */
   13729           0 :     if( state->prectype==0 )
   13730             :     {
   13731             :         
   13732             :         /*
   13733             :          * Default preconditioner - inverse of matrix diagonal
   13734             :          */
   13735           0 :         for(i=0; i<=n-1; i++)
   13736             :         {
   13737           0 :             v = sparsegetdiagonal(a, i, _state);
   13738           0 :             if( ae_fp_greater(v,(double)(0)) )
   13739             :             {
   13740           0 :                 state->tmpd.ptr.p_double[i] = 1/ae_sqrt(v, _state);
   13741             :             }
   13742             :             else
   13743             :             {
   13744           0 :                 state->tmpd.ptr.p_double[i] = (double)(1);
   13745             :             }
   13746             :         }
   13747             :     }
   13748             :     else
   13749             :     {
   13750             :         
   13751             :         /*
   13752             :          * No diagonal scaling
   13753             :          */
   13754           0 :         for(i=0; i<=n-1; i++)
   13755             :         {
   13756           0 :             state->tmpd.ptr.p_double[i] = (double)(1);
   13757             :         }
   13758             :     }
   13759             :     
   13760             :     /*
   13761             :      * Solve
   13762             :      */
   13763           0 :     lincgrestart(state, _state);
   13764           0 :     lincgsetb(state, b, _state);
   13765           0 :     while(lincgiteration(state, _state))
   13766             :     {
   13767             :         
   13768             :         /*
   13769             :          * Process different requests from optimizer
   13770             :          */
   13771           0 :         if( state->needmv )
   13772             :         {
   13773           0 :             sparsesmv(a, isupper, &state->x, &state->mv, _state);
   13774             :         }
   13775           0 :         if( state->needvmv )
   13776             :         {
   13777           0 :             sparsesmv(a, isupper, &state->x, &state->mv, _state);
   13778           0 :             vmv = ae_v_dotproduct(&state->x.ptr.p_double[0], 1, &state->mv.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13779           0 :             state->vmv = vmv;
   13780             :         }
   13781           0 :         if( state->needprec )
   13782             :         {
   13783           0 :             for(i=0; i<=n-1; i++)
   13784             :             {
   13785           0 :                 state->pv.ptr.p_double[i] = state->x.ptr.p_double[i]*ae_sqr(state->tmpd.ptr.p_double[i], _state);
   13786             :             }
   13787             :         }
   13788             :     }
   13789           0 : }
   13790             : 
   13791             : 
   13792             : /*************************************************************************
   13793             : CG-solver: results.
   13794             : 
   13795             : This function must be called after LinCGSolve
   13796             : 
   13797             : INPUT PARAMETERS:
   13798             :     State   -   algorithm state
   13799             : 
   13800             : OUTPUT PARAMETERS:
   13801             :     X       -   array[N], solution
   13802             :     Rep     -   optimization report:
   13803             :                 * Rep.TerminationType completetion code:
   13804             :                     * -5    input matrix is either not positive definite,
   13805             :                             too large or too small                            
   13806             :                     * -4    overflow/underflow during solution
   13807             :                             (ill conditioned problem)
   13808             :                     *  1    ||residual||<=EpsF*||b||
   13809             :                     *  5    MaxIts steps was taken
   13810             :                     *  7    rounding errors prevent further progress,
   13811             :                             best point found is returned
   13812             :                 * Rep.IterationsCount contains iterations count
   13813             :                 * NMV countains number of matrix-vector calculations
   13814             : 
   13815             :   -- ALGLIB --
   13816             :      Copyright 14.11.2011 by Bochkanov Sergey
   13817             : *************************************************************************/
   13818           0 : void lincgresults(lincgstate* state,
   13819             :      /* Real    */ ae_vector* x,
   13820             :      lincgreport* rep,
   13821             :      ae_state *_state)
   13822             : {
   13823             : 
   13824           0 :     ae_vector_clear(x);
   13825           0 :     _lincgreport_clear(rep);
   13826             : 
   13827           0 :     ae_assert(!state->running, "LinCGResult: you can not get result, because function LinCGIteration has been launched!", _state);
   13828           0 :     if( x->cnt<state->n )
   13829             :     {
   13830           0 :         ae_vector_set_length(x, state->n, _state);
   13831             :     }
   13832           0 :     ae_v_move(&x->ptr.p_double[0], 1, &state->rx.ptr.p_double[0], 1, ae_v_len(0,state->n-1));
   13833           0 :     rep->iterationscount = state->repiterationscount;
   13834           0 :     rep->nmv = state->repnmv;
   13835           0 :     rep->terminationtype = state->repterminationtype;
   13836           0 :     rep->r2 = state->r2;
   13837           0 : }
   13838             : 
   13839             : 
   13840             : /*************************************************************************
   13841             : This function sets restart frequency. By default, algorithm  is  restarted
   13842             : after N subsequent iterations.
   13843             : 
   13844             :   -- ALGLIB --
   13845             :      Copyright 14.11.2011 by Bochkanov Sergey
   13846             : *************************************************************************/
   13847           0 : void lincgsetrestartfreq(lincgstate* state,
   13848             :      ae_int_t srf,
   13849             :      ae_state *_state)
   13850             : {
   13851             : 
   13852             : 
   13853           0 :     ae_assert(!state->running, "LinCGSetRestartFreq: you can not change restart frequency when LinCGIteration() is running", _state);
   13854           0 :     ae_assert(srf>0, "LinCGSetRestartFreq: non-positive SRF", _state);
   13855           0 :     state->itsbeforerestart = srf;
   13856           0 : }
   13857             : 
   13858             : 
   13859             : /*************************************************************************
   13860             : This function sets frequency of residual recalculations.
   13861             : 
   13862             : Algorithm updates residual r_k using iterative formula,  but  recalculates
   13863             : it from scratch after each 10 iterations. It is done to avoid accumulation
   13864             : of numerical errors and to stop algorithm when r_k starts to grow.
   13865             : 
   13866             : Such low update frequence (1/10) gives very  little  overhead,  but  makes
   13867             : algorithm a bit more robust against numerical errors. However, you may
   13868             : change it 
   13869             : 
   13870             : INPUT PARAMETERS:
   13871             :     Freq    -   desired update frequency, Freq>=0.
   13872             :                 Zero value means that no updates will be done.
   13873             : 
   13874             :   -- ALGLIB --
   13875             :      Copyright 14.11.2011 by Bochkanov Sergey
   13876             : *************************************************************************/
   13877           0 : void lincgsetrupdatefreq(lincgstate* state,
   13878             :      ae_int_t freq,
   13879             :      ae_state *_state)
   13880             : {
   13881             : 
   13882             : 
   13883           0 :     ae_assert(!state->running, "LinCGSetRUpdateFreq: you can not change update frequency when LinCGIteration() is running", _state);
   13884           0 :     ae_assert(freq>=0, "LinCGSetRUpdateFreq: non-positive Freq", _state);
   13885           0 :     state->itsbeforerupdate = freq;
   13886           0 : }
   13887             : 
   13888             : 
   13889             : /*************************************************************************
   13890             : This function turns on/off reporting.
   13891             : 
   13892             : INPUT PARAMETERS:
   13893             :     State   -   structure which stores algorithm state
   13894             :     NeedXRep-   whether iteration reports are needed or not
   13895             : 
   13896             : If NeedXRep is True, algorithm will call rep() callback function if  it is
   13897             : provided to MinCGOptimize().
   13898             : 
   13899             :   -- ALGLIB --
   13900             :      Copyright 14.11.2011 by Bochkanov Sergey
   13901             : *************************************************************************/
   13902           0 : void lincgsetxrep(lincgstate* state, ae_bool needxrep, ae_state *_state)
   13903             : {
   13904             : 
   13905             : 
   13906           0 :     state->xrep = needxrep;
   13907           0 : }
   13908             : 
   13909             : 
   13910             : /*************************************************************************
   13911             : Procedure for restart function LinCGIteration
   13912             : 
   13913             :   -- ALGLIB --
   13914             :      Copyright 14.11.2011 by Bochkanov Sergey
   13915             : *************************************************************************/
   13916           0 : void lincgrestart(lincgstate* state, ae_state *_state)
   13917             : {
   13918             : 
   13919             : 
   13920           0 :     ae_vector_set_length(&state->rstate.ia, 0+1, _state);
   13921           0 :     ae_vector_set_length(&state->rstate.ra, 2+1, _state);
   13922           0 :     state->rstate.stage = -1;
   13923           0 :     lincg_clearrfields(state, _state);
   13924           0 : }
   13925             : 
   13926             : 
   13927             : /*************************************************************************
   13928             : Clears request fileds (to be sure that we don't forgot to clear something)
   13929             : *************************************************************************/
   13930           0 : static void lincg_clearrfields(lincgstate* state, ae_state *_state)
   13931             : {
   13932             : 
   13933             : 
   13934           0 :     state->xupdated = ae_false;
   13935           0 :     state->needmv = ae_false;
   13936           0 :     state->needmtv = ae_false;
   13937           0 :     state->needmv2 = ae_false;
   13938           0 :     state->needvmv = ae_false;
   13939           0 :     state->needprec = ae_false;
   13940           0 : }
   13941             : 
   13942             : 
   13943             : /*************************************************************************
   13944             : Clears request fileds (to be sure that we don't forgot to clear something)
   13945             : *************************************************************************/
   13946           0 : static void lincg_updateitersdata(lincgstate* state, ae_state *_state)
   13947             : {
   13948             : 
   13949             : 
   13950           0 :     state->repiterationscount = 0;
   13951           0 :     state->repnmv = 0;
   13952           0 :     state->repterminationtype = 0;
   13953           0 : }
   13954             : 
   13955             : 
   13956           0 : void _lincgstate_init(void* _p, ae_state *_state, ae_bool make_automatic)
   13957             : {
   13958           0 :     lincgstate *p = (lincgstate*)_p;
   13959           0 :     ae_touch_ptr((void*)p);
   13960           0 :     ae_vector_init(&p->rx, 0, DT_REAL, _state, make_automatic);
   13961           0 :     ae_vector_init(&p->b, 0, DT_REAL, _state, make_automatic);
   13962           0 :     ae_vector_init(&p->cx, 0, DT_REAL, _state, make_automatic);
   13963           0 :     ae_vector_init(&p->cr, 0, DT_REAL, _state, make_automatic);
   13964           0 :     ae_vector_init(&p->cz, 0, DT_REAL, _state, make_automatic);
   13965           0 :     ae_vector_init(&p->p, 0, DT_REAL, _state, make_automatic);
   13966           0 :     ae_vector_init(&p->r, 0, DT_REAL, _state, make_automatic);
   13967           0 :     ae_vector_init(&p->z, 0, DT_REAL, _state, make_automatic);
   13968           0 :     ae_vector_init(&p->x, 0, DT_REAL, _state, make_automatic);
   13969           0 :     ae_vector_init(&p->mv, 0, DT_REAL, _state, make_automatic);
   13970           0 :     ae_vector_init(&p->pv, 0, DT_REAL, _state, make_automatic);
   13971           0 :     ae_vector_init(&p->startx, 0, DT_REAL, _state, make_automatic);
   13972           0 :     ae_vector_init(&p->tmpd, 0, DT_REAL, _state, make_automatic);
   13973           0 :     _rcommstate_init(&p->rstate, _state, make_automatic);
   13974           0 : }
   13975             : 
   13976             : 
   13977           0 : void _lincgstate_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   13978             : {
   13979           0 :     lincgstate *dst = (lincgstate*)_dst;
   13980           0 :     lincgstate *src = (lincgstate*)_src;
   13981           0 :     ae_vector_init_copy(&dst->rx, &src->rx, _state, make_automatic);
   13982           0 :     ae_vector_init_copy(&dst->b, &src->b, _state, make_automatic);
   13983           0 :     dst->n = src->n;
   13984           0 :     dst->prectype = src->prectype;
   13985           0 :     ae_vector_init_copy(&dst->cx, &src->cx, _state, make_automatic);
   13986           0 :     ae_vector_init_copy(&dst->cr, &src->cr, _state, make_automatic);
   13987           0 :     ae_vector_init_copy(&dst->cz, &src->cz, _state, make_automatic);
   13988           0 :     ae_vector_init_copy(&dst->p, &src->p, _state, make_automatic);
   13989           0 :     ae_vector_init_copy(&dst->r, &src->r, _state, make_automatic);
   13990           0 :     ae_vector_init_copy(&dst->z, &src->z, _state, make_automatic);
   13991           0 :     dst->alpha = src->alpha;
   13992           0 :     dst->beta = src->beta;
   13993           0 :     dst->r2 = src->r2;
   13994           0 :     dst->meritfunction = src->meritfunction;
   13995           0 :     ae_vector_init_copy(&dst->x, &src->x, _state, make_automatic);
   13996           0 :     ae_vector_init_copy(&dst->mv, &src->mv, _state, make_automatic);
   13997           0 :     ae_vector_init_copy(&dst->pv, &src->pv, _state, make_automatic);
   13998           0 :     dst->vmv = src->vmv;
   13999           0 :     ae_vector_init_copy(&dst->startx, &src->startx, _state, make_automatic);
   14000           0 :     dst->epsf = src->epsf;
   14001           0 :     dst->maxits = src->maxits;
   14002           0 :     dst->itsbeforerestart = src->itsbeforerestart;
   14003           0 :     dst->itsbeforerupdate = src->itsbeforerupdate;
   14004           0 :     dst->xrep = src->xrep;
   14005           0 :     dst->xupdated = src->xupdated;
   14006           0 :     dst->needmv = src->needmv;
   14007           0 :     dst->needmtv = src->needmtv;
   14008           0 :     dst->needmv2 = src->needmv2;
   14009           0 :     dst->needvmv = src->needvmv;
   14010           0 :     dst->needprec = src->needprec;
   14011           0 :     dst->repiterationscount = src->repiterationscount;
   14012           0 :     dst->repnmv = src->repnmv;
   14013           0 :     dst->repterminationtype = src->repterminationtype;
   14014           0 :     dst->running = src->running;
   14015           0 :     ae_vector_init_copy(&dst->tmpd, &src->tmpd, _state, make_automatic);
   14016           0 :     _rcommstate_init_copy(&dst->rstate, &src->rstate, _state, make_automatic);
   14017           0 : }
   14018             : 
   14019             : 
   14020           0 : void _lincgstate_clear(void* _p)
   14021             : {
   14022           0 :     lincgstate *p = (lincgstate*)_p;
   14023           0 :     ae_touch_ptr((void*)p);
   14024           0 :     ae_vector_clear(&p->rx);
   14025           0 :     ae_vector_clear(&p->b);
   14026           0 :     ae_vector_clear(&p->cx);
   14027           0 :     ae_vector_clear(&p->cr);
   14028           0 :     ae_vector_clear(&p->cz);
   14029           0 :     ae_vector_clear(&p->p);
   14030           0 :     ae_vector_clear(&p->r);
   14031           0 :     ae_vector_clear(&p->z);
   14032           0 :     ae_vector_clear(&p->x);
   14033           0 :     ae_vector_clear(&p->mv);
   14034           0 :     ae_vector_clear(&p->pv);
   14035           0 :     ae_vector_clear(&p->startx);
   14036           0 :     ae_vector_clear(&p->tmpd);
   14037           0 :     _rcommstate_clear(&p->rstate);
   14038           0 : }
   14039             : 
   14040             : 
   14041           0 : void _lincgstate_destroy(void* _p)
   14042             : {
   14043           0 :     lincgstate *p = (lincgstate*)_p;
   14044           0 :     ae_touch_ptr((void*)p);
   14045           0 :     ae_vector_destroy(&p->rx);
   14046           0 :     ae_vector_destroy(&p->b);
   14047           0 :     ae_vector_destroy(&p->cx);
   14048           0 :     ae_vector_destroy(&p->cr);
   14049           0 :     ae_vector_destroy(&p->cz);
   14050           0 :     ae_vector_destroy(&p->p);
   14051           0 :     ae_vector_destroy(&p->r);
   14052           0 :     ae_vector_destroy(&p->z);
   14053           0 :     ae_vector_destroy(&p->x);
   14054           0 :     ae_vector_destroy(&p->mv);
   14055           0 :     ae_vector_destroy(&p->pv);
   14056           0 :     ae_vector_destroy(&p->startx);
   14057           0 :     ae_vector_destroy(&p->tmpd);
   14058           0 :     _rcommstate_destroy(&p->rstate);
   14059           0 : }
   14060             : 
   14061             : 
   14062           0 : void _lincgreport_init(void* _p, ae_state *_state, ae_bool make_automatic)
   14063             : {
   14064           0 :     lincgreport *p = (lincgreport*)_p;
   14065           0 :     ae_touch_ptr((void*)p);
   14066           0 : }
   14067             : 
   14068             : 
   14069           0 : void _lincgreport_init_copy(void* _dst, void* _src, ae_state *_state, ae_bool make_automatic)
   14070             : {
   14071           0 :     lincgreport *dst = (lincgreport*)_dst;
   14072           0 :     lincgreport *src = (lincgreport*)_src;
   14073           0 :     dst->iterationscount = src->iterationscount;
   14074           0 :     dst->nmv = src->nmv;
   14075           0 :     dst->terminationtype = src->terminationtype;
   14076           0 :     dst->r2 = src->r2;
   14077           0 : }
   14078             : 
   14079             : 
   14080           0 : void _lincgreport_clear(void* _p)
   14081             : {
   14082           0 :     lincgreport *p = (lincgreport*)_p;
   14083           0 :     ae_touch_ptr((void*)p);
   14084           0 : }
   14085             : 
   14086             : 
   14087           0 : void _lincgreport_destroy(void* _p)
   14088             : {
   14089           0 :     lincgreport *p = (lincgreport*)_p;
   14090           0 :     ae_touch_ptr((void*)p);
   14091           0 : }
   14092             : 
   14093             : 
   14094             : #endif
   14095             : 
   14096             : }
   14097             : 

Generated by: LCOV version 1.16