Merge branch 'master' into merge_tostring

Author: zoziha

.github/workflows/CI.yml

@@ -3,7 +3,6 @@ name: CI
 on: [push, pull_request]
 
 env:
-  CI: "ON" # We can detect this in the build system and other vendors implement it
   CMAKE_BUILD_PARALLEL_LEVEL: "2" # 2 cores on each GHA VM, enable parallel builds
   CTEST_OUTPUT_ON_FAILURE: "ON" # This way we don't need a flag to ctest
   CTEST_PARALLEL_LEVEL: "2"
@@ -28,7 +27,7 @@ jobs:
 
     steps:
     - name: Checkout code
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
 
     - name: Set up Python 3.x
       uses: actions/setup-python@v1 # Use pip to install latest CMake, & FORD/Jin2For, etc.
@@ -62,20 +61,19 @@ jobs:
       run: >-
         cmake -Wdev
         -DCMAKE_BUILD_TYPE=Release
-        -DCMAKE_MAXIMUM_RANK=4
+        -DCMAKE_MAXIMUM_RANK:String=4
         -DCMAKE_INSTALL_PREFIX=$PWD/_dist
         -S . -B build
 
     - name: Build and compile
-      run: cmake --build build
+      run: cmake --build build --parallel
 
     - name: catch build fail
       run: cmake --build build --verbose --parallel 1
       if: failure()
 
     - name: test
-      run: ctest --parallel --output-on-failure
-      working-directory: build
+      run: ctest --test-dir build --parallel --output-on-failure
 
     - name: Install project
       run: cmake --install build
@@ -110,7 +108,7 @@ jobs:
 
     steps:
     - name: Checkout code
-      uses: actions/checkout@v1
+      uses: actions/checkout@v2
 
     - name: Set up Python 3.x
       uses: actions/setup-python@v1
@@ -179,7 +177,7 @@ jobs:
       run: >-
          cmake -Wdev
          -DCMAKE_BUILD_TYPE=Release
-         -DCMAKE_MAXIMUM_RANK=4
+         -DCMAKE_MAXIMUM_RANK:String=4
          -DCMAKE_INSTALL_PREFIX=$PWD/_dist
          -S . -B build
 

.github/workflows/PR-review.yml

@@ -6,7 +6,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - name: Check out code.
-        uses: actions/checkout@v1
+        uses: actions/checkout@v2
       - name: misspell
         uses: reviewdog/action-misspell@v1
         with:

.github/workflows/ci_windows.yml

@@ -3,8 +3,8 @@ name: CI_windows
 on: [push, pull_request]
 
 env:
-  CI: "ON"
   CTEST_TIME_TIMEOUT: "5"  # some failures hang forever
+  CMAKE_GENERATOR: Ninja
 
 jobs:
   msys2-build:
@@ -58,13 +58,12 @@ jobs:
       run: pip install fypp
 
     - run: >-
-        cmake -G Ninja
-        -DCMAKE_SH="CMAKE_SH-NOTFOUND"
+        cmake
         -Wdev
         -B build
         -DCMAKE_BUILD_TYPE=Debug
         -DCMAKE_Fortran_FLAGS_DEBUG="-Wall -Wextra -Wimplicit-interface -fPIC -g -fcheck=all -fbacktrace"
-        -DCMAKE_MAXIMUM_RANK=4
+        -DCMAKE_MAXIMUM_RANK:String=4
         -DCMAKE_INSTALL_PREFIX=$PWD/_dist
       env:
         FC: gfortran
@@ -79,8 +78,7 @@ jobs:
       if: failure()
 
     - name: CTest
-      run: ctest --output-on-failure --parallel -V -LE quadruple_precision
-      working-directory: build
+      run: ctest --test-dir build --output-on-failure --parallel -V -LE quadruple_precision
 
     - uses: actions/upload-artifact@v1
       if: failure()

CMakeLists.txt

@@ -31,25 +31,26 @@ if(CMAKE_Fortran_COMPILER_ID STREQUAL GNU)
     add_compile_options(-pedantic-errors)
   endif()
   add_compile_options(-std=f2018)
-elseif(CMAKE_Fortran_COMPILER_ID STREQUAL Intel)
-  add_compile_options(-warn declarations,general,usage,interfaces,unused)
-  if(CMAKE_Fortran_COMPILER_VERSION VERSION_LESS 18.0)
-    add_compile_options(-stand f15)
+elseif(CMAKE_Fortran_COMPILER_ID MATCHES "^Intel")
+  if(WIN32)
+    add_compile_options(/warn:declarations,general,usage,interfaces,unused)
+    add_compile_options(/stand:f18)
   else()
+    add_compile_options(-warn declarations,general,usage,interfaces,unused)
     add_compile_options(-stand f18)
   endif()
-elseif(CMAKE_Fortran_COMPILER_ID STREQUAL PGI)
-  add_compile_options(-Mdclchk)
 endif()
 
 # --- compiler feature checks
 include(CheckFortranSourceCompiles)
 include(CheckFortranSourceRuns)
-check_fortran_source_runs("i=0; error stop i; end" f18errorstop SRC_EXT f90)
+check_fortran_source_runs("i=0; error stop i; end" f18errorstop)
 check_fortran_source_compiles("real, allocatable :: array(:, :, :, :, :, :, :, :, :, :); end" f03rank SRC_EXT f90)
 check_fortran_source_runs("use, intrinsic :: iso_fortran_env, only : real128; real(real128) :: x; x = x+1; end" f03real128)
 
-option(CMAKE_MAXIMUM_RANK "Maximum array rank for generated procedures" 4)
+if(NOT DEFINED CMAKE_MAXIMUM_RANK)
+  set(CMAKE_MAXIMUM_RANK 4 CACHE STRING "Maximum array rank for generated procedures")
+endif()
 
 # --- find preprocessor
 find_program(FYPP fypp)

README.md

@@ -136,7 +136,7 @@ Important options are
 For example, to configure a build using the Ninja backend and generating procedures up to rank 7, which is installed to your home directory use
 
 ```sh
-cmake -B build -G Ninja -DCMAKE_MAXIMUM_RANK=7 -DCMAKE_INSTALL_PREFIX=$HOME/.local
+cmake -B build -G Ninja -DCMAKE_MAXIMUM_RANK:String=7 -DCMAKE_INSTALL_PREFIX=$HOME/.local
 ```
 
 To build the standard library run

doc/specs/stdlib_math.md

@@ -19,7 +19,7 @@ title: math
 
 #### Description
 
-Returns a value which lies in the given interval [`xmin`, `xmax`] (interval is `xmin` and `xmax` inclusive) and is closest to the input value `x`.  
+Returns a value which lies in the given interval [`xmin`, `xmax`] (interval is `xmin` and `xmax` inclusive) and is closest to the input value `x`.
 
 #### Syntax
 
@@ -35,8 +35,8 @@ Elemental function.
 
 #### Argument(s)
 
-`x`: scalar of either `integer` or `real` type. This argument is `intent(in)`.  
-`xmin`: scalar of either `integer` or `real` type. This argument is `intent(in)`.  
+`x`: scalar of either `integer` or `real` type. This argument is `intent(in)`.
+`xmin`: scalar of either `integer` or `real` type. This argument is `intent(in)`.
 `xmax`: scalar of either `integer` or `real` type, which must be greater than or equal to `xmin`. This argument is `intent(in)`.
 
 Note: All arguments must have same `type` and same `kind`.
@@ -90,3 +90,188 @@ program demo_clip_real
   ! clipped_value <- 3.02500010
 end program demo_clip_real
 ```
+
+### `linspace` - Create a linearly spaced rank one array
+
+#### Description
+
+Returns a linearly spaced rank 1 array from [`start`, `end`]. Optionally, you can specify the length of the returned array by passing `n`.
+
+#### Syntax
+
+`res = [[stdlib_math(module):linspace(interface)]] (start, end [, n])`
+
+#### Status
+
+Experimental
+
+#### Class
+
+Function.
+
+#### Argument(s)
+
+`start`: Shall be scalar of any numeric type or kind. This argument is `intent(in)`.
+`end`: Shall be the same `type` and `kind` as `start`. This argument is `intent(in)`.
+`n`: Shall be an integer specifying the length of the output. This argument is `optional` and `intent(in)`.
+
+#### Output value or Result value
+
+The output is a rank 1 array whose length is either 100 (default value) or `n`.
+
+If `n` == 1, return a rank 1 array whose only element is `end`.
+If `n` <= 0, return a rank 1 array with length 0.
+
+If `start`/`end` are `real` or `complex` types, the `result` will be of the same type and kind as `start`/`end`.
+If `start`/`end` are `integer` types, the `result` will default to a `real(dp)` array.
+
+#### Examples
+
+##### Example 1:
+
+Here inputs are of type `complex` and kind `dp`
+```fortran
+program demo_linspace_complex
+  use stdlib_math, only: linspace
+  use stdlib_kinds, only: dp
+  implicit none
+
+  complex(dp) :: start = complex(10.0_dp, 5.0_dp)
+  complex(dp) :: end = complex(-10.0_dp, 15.0_dp)
+
+  complex(dp) :: z(11)
+
+  z = linspace(start, end, 11)
+end program demo_linspace_complex
+```
+
+##### Example 2:
+
+Here inputs are of type `integer` and kind `int16`, with the result defaulting to `real(dp)`.
+```fortran
+program demo_linspace_int16
+  use stdlib_math, only: linspace
+  use stdlib_kinds, only: int16, dp
+  implicit none
+
+  integer(int16) :: start = 10_int16
+  integer(int16) :: end = 23_int16
+
+  real(dp) :: r(15)
+
+  r = linspace(start, end, 15)
+end program demo_linspace_int16
+```
+
+### `logspace` - Create a logarithmically spaced rank one array
+
+#### Description
+
+Returns a logarithmically spaced rank 1 array from [`base`^`start`, `base`^`end`]. The default size of the array is 50. Optionally, you can specify the length of the returned array by passing `n`. You can also specify the `base` used to compute the range (default 10).
+
+#### Syntax
+
+`res = [[stdlib_math(module):logspace(interface)]] (start, end [, n [, base]])`
+
+#### Status
+
+Experimental
+
+#### Class
+
+Function.
+
+#### Argument(s)
+
+`start`: Shall be a scalar of any numeric type. All kinds are supported for real and complex arguments. For integers, only the default kind is currently implemented. This argument is `intent(in)`.
+`end`: Shall be the same `type` and `kind` as `start`. This argument is `intent(in)`.
+`n`: Shall be an integer specifying the length of the output. This argument is `optional` and `intent(in)`.
+`base` : Shall be a scalar of any numeric type. All kinds are supported for real and complex arguments. For integers, only the default kind is currently implemented. This argument is `optional` and `intent(in)`.
+
+#### Output value or Result value
+
+The output is a rank 1 array whose length is either 50 (default value) or `n`.
+
+If `n` == 1, return a rank 1 array whose only element is `base`^`end`.
+If `n` <= 0, return a rank 1 array with length 0
+
+The `type` and `kind` of the output is dependent on the `type` and `kind` of the passed parameters.
+
+For function calls where the `base` is not specified: `logspace(start, end)`/`logspace(start, end, n)`, the `type` and `kind` of
+the output follows the same scheme as above for `linspace`.
+>If `start`/`end` are `real` or `complex` types, the `result` will be the same type and kind as `start`/`end`.
+>If `start`/`end` are integer types, the `result` will default to a `real(dp)` array.
+
+For function calls where the `base` is specified, the `type` and `kind` of the result is in accordance with the following table:
+
+| `start`/`end` | `n` | `base` | `output` |
+| ------------- | --- | ------ | -------- |
+| `real(KIND)` | `Integer` | `real(KIND)` | `real(KIND)` |
+| "          " | "       " | `complex(KIND)` | `complex(KIND)` |
+| "          " | "       " | `Integer` | `real(KIND)` |
+| `complex(KIND)` | "       " | `real(KIND)` | `complex(KIND)` |
+| "             " | "       " | `complex(KIND)` | `complex(KIND)` |
+| "             " | "       " | `Integer` | `complex(KIND)` |
+| `Integer` | "        " | `real(KIND)` | `real(KIND)` |
+| "              " | "        " | `complex(KIND)` | `complex(KIND)` |
+| "              " | "        " | `Integer` | `Integer` |
+
+#### Examples
+
+##### Example 1:
+
+Here inputs are of type `complex` and kind `dp`. `n` and `base` is not specified and thus default to 50 and 10, respectively.
+```fortran
+program demo_logspace_complex
+  use stdlib_math, only: logspace
+  use stdlib_kinds, only: dp
+  implicit none
+
+  complex(dp) :: start = (10.0_dp, 5.0_dp)
+  complex(dp) :: end = (-10.0_dp, 15.0_dp)
+
+  complex(dp) :: z(11) ! Complex values raised to complex powers results in complex values
+
+  z = logspace(start, end, 11)
+end program demo_logspace_complex
+```
+
+##### Example 2:
+
+Here inputs are of type `integer` and default kind. `base` is not specified and thus defaults to 10.
+```fortran
+program demo_logspace_int
+  use stdlib_math, only: logspace
+  use stdlib_kinds, only: dp
+  implicit none
+
+  integer :: start = 10
+  integer :: end = 23
+  integer :: n = 15
+
+  real(dp) :: r(n) ! Integer values raised to real powers results in real values
+
+  r = logspace(start, end, n)
+end program demo_logspace_int
+```
+
+##### Example 3:
+
+Here `start`/`end` are of type `real` and double precision. `base` is type `complex` and also double precision.
+```fortran
+program demo_logspace_rstart_cbase
+  use stdlib_math, only: logspace
+  use stdlib_kinds, only: dp
+  implicit none
+
+  real(dp) :: start = 0.0_dp
+  real(dp) :: end = 3.0_dp
+  integer :: n = 4
+  complex(dp) :: base = (0.0_dp, 1.0_dp)
+
+  complex(dp) :: z(n) ! complex values raised to real powers result in complex values
+
+  z = logspace(start, end, n, base)
+
+end program demo_logspace_rstart_cbase
+```