reorder tangnf args

Author: HugoMVale

src/hompack_nf.f90

@@ -721,8 +721,8 @@ subroutine rootnf(state, callbacks, relerr, abserr, y)
 
             ! Calculate Newton step at current estimate 'w'
             call tangnf(callbacks, sa, &
-                        ws%w, ws%wp, state%ypold, state%a, ws%qr, ws%alpha, ws%tz, ws%pivot, &
-                        state%nfe, state%n, state%iflag)
+                        state%n, ws%w, ws%wp, state%ypold, state%a, state%nfe, state%iflag, &
+                        ws%qr, ws%alpha, ws%tz, ws%pivot)
             if (state%iflag > 0) return
 
             ! Next point = current point + Newton step
@@ -857,9 +857,9 @@ subroutine stepnf(state, callbacks, y)
             ! Use linear predictor along tangent direction to start Newton iteration
             state%ypold(1) = one
             state%ypold(2:np1) = zero
-            call tangnf(callbacks, state%s, y, state%yp, state%ypold, state%a, &
-                        ws%qr, ws%alpha, ws%tz, ws%pivot, &
-                        state%nfe, state%n, state%iflag)
+            call tangnf(callbacks, state%s, state%n, y, state%yp, state%ypold, state%a, &
+                        state%nfe, state%iflag, &
+                        ws%qr, ws%alpha, ws%tz, ws%pivot)
 
             if (state%iflag > 0) return
 
@@ -871,9 +871,9 @@ subroutine stepnf(state, callbacks, y)
 
                   ! Calculate the Newton step 'tz' at the current point 'w'
                   call tangnf(callbacks, rholen, &
-                              ws%w, ws%wp, state%ypold, state%a, &
-                              ws%qr, ws%alpha, ws%tz, ws%pivot, &
-                              state%nfe, state%n, state%iflag)
+                              state%n, ws%w, ws%wp, state%ypold, state%a, &
+                              state%nfe, state%iflag, &
+                              ws%qr, ws%alpha, ws%tz, ws%pivot)
                   if (state%iflag > 0) return
 
                   ! Take Newton step and check convergence
@@ -924,9 +924,9 @@ subroutine stepnf(state, callbacks, y)
 
                ! Calculate the Newton step 'tz' at the current point 'w'
                rholen = -one
-               call tangnf(callbacks, &
-                           rholen, ws%w, ws%wp, state%yp, state%a, ws%qr, ws%alpha, ws%tz, ws%pivot, &
-                           state%nfe, state%n, state%iflag)
+               call tangnf(callbacks, rholen, &
+                           state%n, ws%w, ws%wp, state%yp, state%a, state%nfe, &
+                           state%iflag, ws%qr, ws%alpha, ws%tz, ws%pivot)
                if (state%iflag > 0) return
 
                ! Take Newton step and check convergence
@@ -1025,8 +1025,7 @@ subroutine stepnf(state, callbacks, y)
    end subroutine stepnf
 
    subroutine tangnf( &
-      callbacks, &
-      rholen, y, yp, ypold, a, qr, alpha, tz, pivot, nfe, n, iflag)
+      callbacks, rholen, n, y, yp, ypold, a, nfe, iflag, qr, alpha, tz, pivot)
    !! This subroutine builds the Jacobian matrix of the homotopy map, computes a QR
    !! decomposition of that matrix, and then calculates the (unit) tangent vector and the
    !! Newton step.
@@ -1046,6 +1045,8 @@ subroutine tangnf( &
          !!
          !! On output, if `rholen < 0` on entry:
          !! `rholen = ||rho(a, lambda, x)||`. Otherwise the value is unchanged.
+      integer, intent(in) :: n
+         !! Problem dimension.
       real(dp), intent(in) :: y(:)
          !! Current point on the homotopy zero curve. `Shape: (n+1)`.
          !! Contains `(lambda, x)`.
@@ -1058,23 +1059,9 @@ subroutine tangnf( &
          !! vector.
       real(dp), intent(in) :: a(:)
          !! Parameter vector used in the homotopy map.
-      real(dp), intent(inout) :: qr(:, :)
-         !! Workspace containing the Jacobian matrix and its QR factorization.
-         !! `Shape: (n, n+2)`.
-      real(dp), intent(inout) :: alpha(:)
-         !! Workspace array used during QR factorization and related linear algebra
-         !! operations. `Shape: (3*n+3)`.
-      real(dp), intent(out) :: tz(:)
-         !! Newton correction vector. `Shape: (n+1)`.
-         !! Equal to the negative pseudoinverse of the homotopy Jacobian applied to the
-         !! homotopy residual.
-      integer, intent(inout) :: pivot(:)
-         !! Pivot indices produced by the QR factorization. `Shape: (n+1)`.
       integer, intent(inout) :: nfe
          !! Number of homotopy/Jacobian evaluations performed.
          !! Incremented by one on every successful call.
-      integer, intent(in) :: n
-         !! Problem dimension.
       integer, intent(inout) :: iflag
          !! Problem type and return status flag.
          !!
@@ -1086,6 +1073,18 @@ subroutine tangnf( &
          !! On output:
          !! * unchanged (`0`, `-1`, or `-2`) on normal return.
          !! * `4` : Jacobian matrix lost full rank (`rank < n`); iteration not completed.
+      real(dp), intent(inout) :: qr(:, :)
+         !! Workspace containing the Jacobian matrix and its QR factorization.
+         !! `Shape: (n, n+2)`.
+      real(dp), intent(inout) :: alpha(:)
+         !! Workspace array used during QR factorization and related linear algebra
+         !! operations. `Shape: (3*n+3)`.
+      real(dp), intent(out) :: tz(:)
+         !! Newton correction vector. `Shape: (n+1)`.
+         !! Equal to the negative pseudoinverse of the homotopy Jacobian applied to the
+         !! homotopy residual.
+      integer, intent(inout) :: pivot(:)
+         !! Pivot indices produced by the QR factorization. `Shape: (n+1)`.
 
       real(dp) :: lambda, sigma, ypnorm
       integer :: i, j, k, kp1, np1, np2, info

test/test_f.f90

@@ -336,16 +336,16 @@ subroutine mainx
             cycle track
          end if
          rholen = 0d0
-         call tangnf(callbacks, &
-                     rholen, w, wp, ypold, a, qr, alpha, tz, pivot, nfec, n, iflag)
+         call tangnf(callbacks, rholen, n, w, wp, ypold, a, nfec, iflag, &
+                     qr, alpha, tz, pivot)
       case (-32:-20)   ! TANGENT VECTOR AND NEWTON STEP
          if (h > .1_dp) then
             iflag = iflag - 100
             cycle track
          end if
          rholen = -1d0
-         call tangnf(callbacks, &
-                     rholen, w, wp, ypold, a, qr, alpha, tz, pivot, nfec, n, iflag)
+         call tangnf(callbacks, rholen, n, w, wp, ypold, a, nfec, iflag, &
+                     qr, alpha, tz, pivot)
       case (4, 6, 7)
          write (6, 13) iflag
 13       format(/' FATAL ERROR OCCURRED DURING TRACKING WITH', &
@@ -373,8 +373,8 @@ subroutine mainx
          gofw = w(1) - 1d0
       case (-52:-50)   ! TANGENT VECTOR AND NEWTON STEP
          rholen = -1d0
-         call tangnf(callbacks, &
-                     rholen, w, wp, ypold, a, qr, alpha, tz, pivot, nfec, n, iflag)
+         call tangnf(callbacks, rholen, n, w, wp, ypold, a, nfec, iflag, &
+                     qr, alpha, tz, pivot)
       case (-2:0, 4, 6, 7)
          exit end_game
       end select