Merge branch 'master' of https://github.com/jalvesz/stdlib

jalvesz · jalvesz · commit c6160955636a · 2023-09-14T08:29:44.000+02:00
diff --git a/.github/workflows/CI.yml b/.github/workflows/CI.yml
@@ -20,7 +20,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, macos-latest]
-        gcc_v: [10, 11, 12] # Version of GFortran we want to use.
+        gcc_v: [10, 11, 12, 13] # Version of GFortran we want to use.
         build: [cmake]
         include:
           - os: ubuntu-latest
diff --git a/README.md b/README.md
@@ -87,8 +87,8 @@ The following combinations are tested on the default branch of stdlib:
 
 Name | Version | Platform | Architecture
 --- | --- | --- | ---
-GCC Fortran | 10, 11, 12 | Ubuntu 22.04.2 LTS | x86_64
-GCC Fortran | 10, 11, 12 | macOS 12.6.3 (21G419) | x86_64
+GCC Fortran | 10, 11, 12, 13 | Ubuntu 22.04.2 LTS | x86_64
+GCC Fortran | 10, 11, 12, 13 | macOS 12.6.3 (21G419) | x86_64
 GCC Fortran (MSYS) | 10 | Windows Server 2022 (10.0.20348 Build 1547) | x86_64
 GCC Fortran (MinGW) | 10 | Windows Server 2022 (10.0.20348 Build 1547) | x86_64, i686
 Intel oneAPI classic | 2021.1 | Ubuntu 22.04.2 LTS | x86_64
diff --git a/doc/specs/stdlib_string_type.md b/doc/specs/stdlib_string_type.md
@@ -1523,6 +1523,7 @@ Experimental
 Moves the allocation from `from` to `to`, consequently deallocating `from` in this process.
 If `from` is not allocated before execution, `to` gets deallocated by the process.
 An unallocated `string_type` instance is equivalent to an empty string.
+If `from` and `to` are the same variable, then `from` remains unchanged.
 
 #### Syntax
 
@@ -1537,7 +1538,8 @@ Pure subroutine (Elemental subroutine, only when both `from` and `to` are `type(
 - `from`: Character scalar or [[stdlib_string_type(module):string_type(type)]].
   This argument is `intent(inout)`.
 - `to`: Character scalar or [[stdlib_string_type(module):string_type(type)]].
-  This argument is `intent(out)`.
+  This argument is `intent(inout)` when both `from` and `to` are `type(string_type)`,
+  otherwise `intent(out)`.
 
 #### Example
 
diff --git a/src/stdlib_specialfunctions_gamma.fypp b/src/stdlib_specialfunctions_gamma.fypp
@@ -298,14 +298,14 @@ contains
 
         end if
 
-        if(z % re > zero_k1) then
+        if(z % re < zero_k1) then
 
-            y = z - one
+            x = cmplx(abs(z % re), - z % im, kind = ${k1}$)
+            y = x - one
 
         else
 
-            x = cmplx(abs(z % re), - z % im, kind = ${k1}$)
-            y = x - one
+            y = z - one
 
         end if
 
diff --git a/src/stdlib_string_type.fypp b/src/stdlib_string_type.fypp
@@ -680,9 +680,11 @@ contains
     !> No output
     elemental subroutine move_string_string(from, to)
         type(string_type), intent(inout) :: from
-        type(string_type), intent(out) :: to
+        type(string_type), intent(inout) :: to
+        character(:), allocatable :: tmp
 
-        call move_alloc(from%raw, to%raw)
+        call move_alloc(from%raw, tmp)
+        call move_alloc(tmp, to%raw)
 
     end subroutine move_string_string
 
diff --git a/test/specialfunctions/test_specialfunctions_gamma.fypp b/test/specialfunctions/test_specialfunctions_gamma.fypp
@@ -96,21 +96,21 @@ contains
                                          4.78749174, 3.63739376e2]
 
         #:elif k1 == "int16"
-        
+
         ${t1}$, parameter :: x(n) = [0_${k1}$, 1_${k1}$, 2_${k1}$, 4_${k1}$,   &
                                      7_${k1}$, 500_${k1}$]
         real(sp), parameter :: ans(n) = [0.0, 0.0, 0.693147180, 3.17805383,    &
                                          8.52516136, 2.61133046e3]
 
         #:elif k1 == "int32"
-        
+
         ${t1}$, parameter :: x(n) = [0_${k1}$, 1_${k1}$, 2_${k1}$, 4_${k1}$,   &
                                      12_${k1}$, 7000_${k1}$]
         real(sp), parameter :: ans(n) = [0.0, 0.0, 0.693147180, 3.17805383,    &
                                          1.99872145e1, 5.49810038e4]
 
         #:elif k1 == "int64"
-        
+
         ${t1}$, parameter :: x(n) = [0_${k1}$, 1_${k1}$, 2_${k1}$, 4_${k1}$,   &
                                      20_${k1}$, 90000_${k1}$]
         real(sp), parameter :: ans(n) = [0.0, 0.0, 0.693147180, 3.17805383,    &
@@ -134,42 +134,46 @@ contains
 
     subroutine test_gamma_${t1[0]}$${k1}$(error)
         type(error_type), allocatable, intent(out) :: error
-        integer, parameter :: n = 4
+        integer, parameter :: n = 5
         integer :: i
 
         #:if k1 == "int8"
 
-        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 6_${k1}$]
-        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$, 120_${k1}$]
+        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 5_${k1}$, 6_${k1}$]
+        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$, 24_${k1}$, 120_${k1}$]
 
         #:elif k1 == "int16"
 
-        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 8_${k1}$]
-        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$, 5040_${k1}$]
+        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 5_${k1}$, 8_${k1}$]
+        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$, 24_${k1}$, 5040_${k1}$]
 
         #:elif k1 == "int32"
 
-        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 13_${k1}$]
-        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$,           &
+        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 8_${k1}$, 13_${k1}$]
+        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$, 5040_${k1}$, &
                                       479001600_${k1}$]
 
         #:elif k1 == "int64"
 
-        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 21_${k1}$]
-        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$,           &
+        ${t1}$, parameter :: x(n) = [1_${k1}$, 2_${k1}$, 4_${k1}$, 13_${k1}$, 21_${k1}$]
+        ${t1}$, parameter :: ans(n) = [1_${k1}$, 1_${k1}$, 6_${k1}$, 479001600_${k1}$, &
                                       2432902008176640000_${k1}$]
         #:elif t1[0] == "c"
 
         ${t1}$, parameter :: x(n) = [(0.25_${k1}$, 0.25_${k1}$),               &
                                      (0.5_${k1}$, -0.5_${k1}$),                &
                                      (1.0_${k1}$, 1.0_${k1}$),                 &
-                                     (-1.254e1_${k1}$, -9.87_${k1}$)]
+                                     (-1.254e1_${k1}$, -9.87_${k1}$),          &
+                                     (0.0_${k1}$, 1.0_${k1}$)                  &
+                                    ]
 
         ${t1}$, parameter :: ans(n) =                                          &
                      [(1.6511332803889208_${k1}$, -1.8378758749947890_${k1}$), &
                       (0.81816399954174739_${k1}$, 0.76331382871398262_${k1}$),&
                      (0.49801566811835604_${k1}$, -0.15494982830181069_${k1}$),&
-             (-2.18767396709283064e-21_${k1}$, 2.77577940846953455e-21_${k1}$)]
+             (-2.18767396709283064e-21_${k1}$, 2.77577940846953455e-21_${k1}$),&
+                    (-0.15494982830181067_${k1}$, -0.49801566811835607_${k1}$) &
+             ]
         #:endif
 
 
diff --git a/test/string/test_string_intrinsic.f90 b/test/string/test_string_intrinsic.f90
@@ -667,6 +667,7 @@ subroutine test_move(error)
         !> Error handling
         type(error_type), allocatable, intent(out) :: error
         type(string_type) :: from_string, to_string
+        type(string_type) :: from_string_not
         type(string_type) :: from_strings(2), to_strings(2)
         character(len=:), allocatable :: from_char, to_char
 
@@ -706,20 +707,32 @@ subroutine test_move(error)
         call check(error, .not. allocated(from_char) .and. from_string == "new char", "move: test_case 6")
         if (allocated(error)) return
 
-        ! character (unallocated) --> string_type (allocated)
+        ! character (not allocated) --> string_type (allocated)
         call move(from_char, from_string)
         call check(error, from_string == "", "move: test_case 7")
         if (allocated(error)) return
 
         from_string = "moving to self"
         ! string_type (allocated) --> string_type (allocated)
         call move(from_string, from_string)
-        call check(error, from_string == "", "move: test_case 8")
+        call check(error, from_string == "moving to self", "move: test_case 8")
         if (allocated(error)) return
         
         ! elemental: string_type (allocated) --> string_type (not allocated)
         call move(from_strings, to_strings)
         call check(error, all(from_strings(:) == "") .and. all(to_strings(:) == "Move This String"), "move: test_case 9")
+
+        ! string_type (not allocated) --> string_type (not allocated)
+        call move(from_string_not, to_string)
+        call check(error, from_string_not == "" .and. to_string == "", "move: test_case 10")
+        if (allocated(error)) return
+
+        ! string_type (not allocated) --> string_type (not allocated)
+        to_string = "to be deallocated"
+        call move(from_string_not, to_string)
+        call check(error, from_string_not == "" .and. to_string == "", "move: test_case 11")
+        if (allocated(error)) return
+
     end subroutine test_move
 
 end module test_string_intrinsic
