stepan
/
dynare
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
dynare/mex/sources/block_trust_region/dulmage_mendelsohn.f08

73 lines
2.4 KiB
Plaintext
Raw Normal View History

Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
! Wrapper around MATLAB’s dmperm to compute the Dulmage-Mendelsohn
! decomposition
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
! Copyright © 2020 Dynare Team
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
!
! This file is part of Dynare.
!
! Dynare is free software: you can redistribute it and/or modify
! it under the terms of the GNU General Public License as published by
! the Free Software Foundation, either version 3 of the License, or
! (at your option) any later version.
!
! Dynare is distributed in the hope that it will be useful,
! but WITHOUT ANY WARRANTY; without even the implied warranty of
! MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
! GNU General Public License for more details.
!
! You should have received a copy of the GNU General Public License
Use secure URL for link to GNU licenses
2021-06-09 17:33:48 +02:00
! along with Dynare. If not, see <https://www.gnu.org/licenses/>.
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
module dulmage_mendelsohn
use iso_fortran_env
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
use matlab_mex
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
implicit none
! Represents a block in the fine DM decomposition
type :: dm_block
integer, dimension(:), allocatable :: row_indices, col_indices
end type dm_block
contains
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
subroutine dm_blocks(mat, blocks)
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
real(real64), dimension(:, :), intent(in) :: mat
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
type(dm_block), dimension(:), allocatable, intent(out) :: blocks
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
type(c_ptr), dimension(1) :: call_rhs
type(c_ptr), dimension(4) :: call_lhs
real(real64), dimension(:, :), pointer :: mat_mx
real(real64), dimension(:), pointer :: p, q, r, s
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
integer :: i, j
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
call_rhs(1) = mxCreateDoubleMatrix(int(size(mat, 1), mwSize), int(size(mat, 2), mwSize), mxREAL)
mat_mx(1:size(mat,1), 1:size(mat,2)) => mxGetPr(call_rhs(1))
mat_mx = mat
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
if (mexCallMATLAB(4_c_int, call_lhs, 1_c_int, call_rhs, "dmperm") /= 0) &
call mexErrMsgTxt("Error calling dmperm")
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
call mxDestroyArray(call_rhs(1))
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
p => mxGetPr(call_lhs(1))
q => mxGetPr(call_lhs(2))
r => mxGetPr(call_lhs(3))
s => mxGetPr(call_lhs(4))
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
allocate(blocks(size(r)-1))
do i = 1, size(r)-1
allocate(blocks(i)%row_indices(int(r(i+1)-r(i))))
do j = 1, int(r(i+1)-r(i))
blocks(i)%row_indices(j) = int(p(j+int(r(i))-1))
end do
allocate(blocks(i)%col_indices(int(s(i+1)-s(i))))
do j = 1, int(s(i+1)-s(i))
blocks(i)%col_indices(j) = int(q(j+int(s(i))-1))
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
end do
end do
Block trust region MEX: use MATLAB’s dmperm for the Dulmage-Mendelsohn decomposition It turns out that MATLAB’s implementation is significantly faster than my own Fortran implementation.
2020-09-08 16:23:32 +02:00
call mxDestroyArray(call_lhs(1))
call mxDestroyArray(call_lhs(2))
call mxDestroyArray(call_lhs(3))
call mxDestroyArray(call_lhs(4))
Add new block_trust_region MEX This MEX solves nonlinear systems of equations using a trust region algorithm. The problem is subdivided in smaller problems by doing a block triangularisation of the Jacobian at the guess value, using the Dulmage-Mendelsohn algorithm. The interface of the MEX is simply: [x, info] = block_trust_region(f, guess_value); Where f is either a function handle or a string designating a function. f must take one argument (the evaluation point), and return either one or two arguments (the residuals and, optionally, the Jacobian). On success, info=0; on failure, info=1.
2019-12-03 16:17:16 +01:00
end subroutine dm_blocks
end module dulmage_mendelsohn