address style changes

address style changes

Author: perazz

src/stdlib_linalg_constants.fypp

@@ -1,7 +1,7 @@
 #:include "common.fypp"
 module stdlib_linalg_constants
      use stdlib_kinds, only: sp, dp, qp, int32, int64, lk
-!$   use omp_lib
+     !$ use omp_lib
      implicit none(type,external)
      public
 

src/stdlib_linalg_state.fypp

@@ -6,17 +6,17 @@ module stdlib_linalg_state
      !! Provides a state/error handling derived type for advanced error handling of
      !! BLAS/LAPACK based linear algebra procedures. All procedures are pure.
      !! !! ([Specification](../page/specs/stdlib_linalg.html))
-     use stdlib_linalg_constants,only:ilp,lk
-     use stdlib_kinds
-     use stdlib_io
-     use iso_fortran_env,only: stderr => error_unit
+     use stdlib_linalg_constants,only: ilp,sp,dp,qp,lk
+     use stdlib_kinds, only: int8, int16, int32, int64
+     use stdlib_io, only: FMT_REAL_SP, FMT_REAL_DP, FMT_REAL_QP, FMT_COMPLEX_SP, FMT_COMPLEX_DP, &
+         FMT_COMPLEX_QP
      implicit none(type,external)
      private
 
      !> Version: experimental
      !>
      !> A fixed-storage state variable for error handling of linear algebra routines
-     public :: linalg_state
+     public :: linalg_state_type
 
      !> Version: experimental
      !>
@@ -32,19 +32,19 @@ module stdlib_linalg_state
      public :: operator(>),operator(>=)
 
      !> State return types
-     integer(ilp),parameter,public :: LINALG_SUCCESS = 0_ilp
-     integer(ilp),parameter,public :: LINALG_VALUE_ERROR = -1_ilp
-     integer(ilp),parameter,public :: LINALG_ERROR = -2_ilp
+     integer(ilp),parameter,public :: LINALG_SUCCESS        = 0_ilp
+     integer(ilp),parameter,public :: LINALG_VALUE_ERROR    = -1_ilp
+     integer(ilp),parameter,public :: LINALG_ERROR          = -2_ilp
      integer(ilp),parameter,public :: LINALG_INTERNAL_ERROR = -3_ilp
 
      !> Use fixed-size character storage for performance
      integer(ilp),parameter :: MSG_LENGTH = 512_ilp
      integer(ilp),parameter :: NAME_LENGTH = 32_ilp
 
-     !> `linalg_state` defines a state return type for a
+     !> `linalg_state_type` defines a state return type for a
      !> linear algebra routine. State contains a status flag, a comment, and a
      !> procedure specifier that can be used to mark where the error happened
-     type :: linalg_state
+     type :: linalg_state_type
 
          !> The current exit state
          integer(ilp) :: state = LINALG_SUCCESS
@@ -58,17 +58,17 @@ module stdlib_linalg_state
          contains
 
             !> Cleanup
-            procedure :: destroy => state_destroy
+            procedure :: destroy   => state_destroy
 
             !> Print error message
-            procedure :: print => state_print
+            procedure :: print     => state_print
             procedure :: print_msg => state_message
 
             !> State properties
-            procedure :: ok => state_is_ok
-            procedure :: error => state_is_error
+            procedure :: ok        => state_is_ok
+            procedure :: error     => state_is_error
 
-     end type linalg_state
+     end type linalg_state_type
 
      !> Comparison operators
      interface operator(==)
@@ -96,15 +96,15 @@ module stdlib_linalg_state
          module procedure flag_ge_state
      end interface
 
-     interface linalg_state
+     interface linalg_state_type
          module procedure new_state
          module procedure new_state_nowhere
-     end interface linalg_state
+     end interface linalg_state_type
 
      contains
 
      !> Interface to print linalg state flags
-     pure function LINALG_MESSAGE(flag) result(msg)
+     pure function linalg_message(flag) result(msg)
         integer(ilp),intent(in) :: flag
         character(len=:),allocatable :: msg
 
@@ -116,12 +116,12 @@ module stdlib_linalg_state
            case default;                 msg = 'ERROR/INVALID FLAG'
         end select
 
-     end function LINALG_MESSAGE
+     end function linalg_message
 
      !> Flow control: on output flag present, return it; otherwise, halt on error
      pure subroutine linalg_error_handling(ierr,ierr_out)
-         type(linalg_state),intent(in) :: ierr
-         type(linalg_state),optional,intent(out) :: ierr_out
+         type(linalg_state_type),intent(in) :: ierr
+         type(linalg_state_type),optional,intent(out) :: ierr_out
 
          character(len=:),allocatable :: err_msg
 
@@ -137,20 +137,20 @@ module stdlib_linalg_state
 
      !> Formatted message
      pure function state_message(this) result(msg)
-         class(linalg_state),intent(in) :: this
+         class(linalg_state_type),intent(in) :: this
          character(len=:),allocatable :: msg
 
          if (this%state == LINALG_SUCCESS) then
             msg = 'Success!'
          else
-            msg = LINALG_MESSAGE(this%state)//': '//trim(this%message)
+            msg = linalg_message(this%state)//': '//trim(this%message)
          end if
 
      end function state_message
 
      !> Produce a nice error string
      pure function state_print(this) result(msg)
-         class(linalg_state),intent(in) :: this
+         class(linalg_state_type),intent(in) :: this
          character(len=:),allocatable :: msg
 
          if (len_trim(this%where_at) > 0) then
@@ -165,7 +165,7 @@ module stdlib_linalg_state
 
      !> Cleanup the object
      elemental subroutine state_destroy(this)
-        class(linalg_state),intent(inout) :: this
+        class(linalg_state_type),intent(inout) :: this
 
         this%state = LINALG_SUCCESS
         this%message = repeat(' ',len(this%message))
@@ -175,102 +175,102 @@ module stdlib_linalg_state
 
      !> Check if the current state is successful
      elemental logical(lk) function state_is_ok(this)
-        class(linalg_state),intent(in) :: this
+        class(linalg_state_type),intent(in) :: this
         state_is_ok = this%state == LINALG_SUCCESS
      end function state_is_ok
 
      !> Check if the current state is an error state
      elemental logical(lk) function state_is_error(this)
-        class(linalg_state),intent(in) :: this
+        class(linalg_state_type),intent(in) :: this
         state_is_error = this%state /= LINALG_SUCCESS
      end function state_is_error
 
      !> Compare an error state with an integer flag
      elemental logical(lk) function state_eq_flag(err,flag)
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         integer,intent(in) :: flag
         state_eq_flag = err%state == flag
      end function state_eq_flag
 
      !> Compare an integer flag with the error state
      elemental logical(lk) function flag_eq_state(flag,err)
         integer,intent(in) :: flag
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         flag_eq_state = err%state == flag
      end function flag_eq_state
 
      !> Compare the error state with an integer flag
      elemental logical(lk) function state_neq_flag(err,flag)
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         integer,intent(in) :: flag
         state_neq_flag = .not. state_eq_flag(err,flag)
      end function state_neq_flag
 
      !> Compare an integer flag with the error state
      elemental logical(lk) function flag_neq_state(flag,err)
         integer,intent(in) :: flag
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         flag_neq_state = .not. state_eq_flag(err,flag)
      end function flag_neq_state
 
      !> Compare the error state with an integer flag
      elemental logical(lk) function state_lt_flag(err,flag)
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         integer,intent(in) :: flag
         state_lt_flag = err%state < flag
      end function state_lt_flag
 
      !> Compare the error state with an integer flag
      elemental logical(lk) function state_le_flag(err,flag)
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         integer,intent(in) :: flag
         state_le_flag = err%state <= flag
      end function state_le_flag
 
      !> Compare an integer flag with the error state
      elemental logical(lk) function flag_lt_state(flag,err)
         integer,intent(in) :: flag
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         flag_lt_state = err%state < flag
      end function flag_lt_state
 
      !> Compare an integer flag with the error state
      elemental logical(lk) function flag_le_state(flag,err)
         integer,intent(in) :: flag
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         flag_le_state = err%state <= flag
      end function flag_le_state
 
      !> Compare the error state with an integer flag
      elemental logical(lk) function state_gt_flag(err,flag)
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         integer,intent(in) :: flag
         state_gt_flag = err%state > flag
      end function state_gt_flag
 
      !> Compare the error state with an integer flag
      elemental logical(lk) function state_ge_flag(err,flag)
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         integer,intent(in) :: flag
         state_ge_flag = err%state >= flag
      end function state_ge_flag
 
      !> Compare an integer flag with the error state
      elemental logical(lk) function flag_gt_state(flag,err)
         integer,intent(in) :: flag
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         flag_gt_state = err%state > flag
      end function flag_gt_state
 
      !> Compare an integer flag with the error state
      elemental logical(lk) function flag_ge_state(flag,err)
         integer,intent(in) :: flag
-        type(linalg_state),intent(in) :: err
+        type(linalg_state_type),intent(in) :: err
         flag_ge_state = err%state >= flag
      end function flag_ge_state
 
     !> Error creation message, with location location
-    pure type(linalg_state) function new_state(where_at,flag,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10, &
+    pure type(linalg_state_type) function new_state(where_at,flag,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10, &
                                                v1,v2,v3,v4,v5)
 
        !> Location
@@ -294,7 +294,7 @@ module stdlib_linalg_state
     end function new_state
 
     !> Error creation message, from N input variables (numeric or strings)
-    pure type(linalg_state) function new_state_nowhere(flag,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10, &
+    pure type(linalg_state_type) function new_state_nowhere(flag,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10, &
                                                v1,v2,v3,v4,v5) result(new_state)
 
        !> Input error flag

test/linalg/test_linalg.fypp

@@ -5,7 +5,7 @@ module test_linalg
     use testdrive, only : new_unittest, unittest_type, error_type, check, skip_test
     use stdlib_kinds, only: sp, dp, xdp, qp, int8, int16, int32, int64
     use stdlib_linalg, only: diag, eye, trace, outer_product, cross_product, kronecker_product
-    use stdlib_linalg_state
+    use stdlib_linalg_state, only: linalg_state_type, LINALG_SUCCESS, linalg_error_handling
 
     implicit none
 
@@ -917,56 +917,56 @@ contains
         !> Error handling
         type(error_type), allocatable, intent(out) :: error
 
-        type(linalg_state) :: state,state_out
+        type(linalg_state_type) :: state,state_out
 
-        state = linalg_state(LINALG_SUCCESS,' 32-bit real: ',1.0_sp)
+        state = linalg_state_type(LINALG_SUCCESS,' 32-bit real: ',1.0_sp)
         call check(error, &
         state%message==' 32-bit real: 1.00000000E+00', &
         "malformed state message with 32-bit reals.")
         if (allocated(error)) return
 
-        state = linalg_state(LINALG_SUCCESS,' 64-bit real: ',1.0_dp)
+        state = linalg_state_type(LINALG_SUCCESS,' 64-bit real: ',1.0_dp)
         call check(error, &
         state%message==' 64-bit real: 1.0000000000000000E+000', &
         "malformed state message with 64-bit reals.")
         if (allocated(error)) return
 
 #:if WITH_QP
-        state = linalg_state(LINALG_SUCCESS,' 128-bit real: ',1.0_qp)
+        state = linalg_state_type(LINALG_SUCCESS,' 128-bit real: ',1.0_qp)
         call check(error, &
         state%message==' 128-bit real: 1.00000000000000000000000000000000000E+0000', &
         "malformed state message with 128-bit reals.")
         if (allocated(error)) return
 #:endif
 
-        state = linalg_state(LINALG_SUCCESS,' 32-bit complex: ',(1.0_sp,1.0_sp))
+        state = linalg_state_type(LINALG_SUCCESS,' 32-bit complex: ',(1.0_sp,1.0_sp))
         call check(error, &
         state%message==' 32-bit complex: (1.00000000E+00,1.00000000E+00)', &
         "malformed state message with 32-bit complex: "//trim(state%message))
         if (allocated(error)) return
 
-        state = linalg_state(LINALG_SUCCESS,' 64-bit complex: ',(1.0_dp,1.0_dp))
+        state = linalg_state_type(LINALG_SUCCESS,' 64-bit complex: ',(1.0_dp,1.0_dp))
         call check(error, &
         state%message==' 64-bit complex: (1.0000000000000000E+000,1.0000000000000000E+000)', &
         "malformed state message with 64-bit complex.")
         if (allocated(error)) return
 
 #:if WITH_QP
-        state = linalg_state(LINALG_SUCCESS,'128-bit complex: ',(1.0_qp,1.0_qp))
+        state = linalg_state_type(LINALG_SUCCESS,'128-bit complex: ',(1.0_qp,1.0_qp))
         call check(error, state%message== &
         '128-bit complex: (1.00000000000000000000000000000000000E+0000,1.00000000000000000000000000000000000E+0000)', &
         "malformed state message with 128-bit complex.")
 
 #:endif
 
-        state = linalg_state(LINALG_SUCCESS,' 32-bit array: ',v1=[(1.0_sp,0.0_sp),(0.0_sp,1.0_sp)])
+        state = linalg_state_type(LINALG_SUCCESS,' 32-bit array: ',v1=[(1.0_sp,0.0_sp),(0.0_sp,1.0_sp)])
         call check(error, state%message== &
         ' 32-bit array: [(1.00000000E+00,0.00000000E+00) (0.00000000E+00,1.00000000E+00)]', &
         "malformed state message with 32-bit real array.")
         if (allocated(error)) return
 
         !> State flag with location
-        state = linalg_state('test_formats',LINALG_SUCCESS,' 32-bit real: ',1.0_sp)
+        state = linalg_state_type('test_formats',LINALG_SUCCESS,' 32-bit real: ',1.0_sp)
         call check(error, &
         state%print()=='[test_formats] returned Success!', &
         "malformed state message with 32-bit real and location.")