Update arange func and doc:

1. `merge` -> `optval` inside.
2. `by` -> `step` argument name.

Author: zoziha

doc/specs/stdlib_math.md

@@ -287,15 +287,15 @@ Pure function.
 
 ### Description
 
-Create a vector of the `integer/real` type with given fixed spaced values within a given interval.
+Create a one-dimensional `array` of the `integer/real` type with fixed-spaced values of given spacing, within a given interval.
 
 #### Note
 
 Because of the `i` (`huge(integer :: i) = 2147483647`) index inside the `arange` function , the dimensional maximum length of array created by the `arange` function is `2147483647`. 
 
 ### Syntax
 
-`result = [[stdlib_math(module):arange(interface)]](start [, end, by])`
+`result = [[stdlib_math(module):arange(interface)]](start [, end, step])`
 
 ### Arguments
 
@@ -309,20 +309,20 @@ The default `start` value is `1`.
 This is an `intent(in)` and `optional` argument.  
 The default `end` value is the inputted `start` value.
 
-`by`: Shall be an `integer/real` scalar and large than `0`. 
+`step`: Shall be an `integer/real` scalar and large than `0`. 
 This is an `intent(in)` and `optional` argument.   
-The default `by` value is `1`.
+The default `step` value is `1`.
 
 #### Warning
-If `by = 0`, the `by` argument will be corrected to `1/1.0` by the internal process of the `arange` function.   
-If `by < 0`, the `by` argument will be corrected to `abs(by)` by the internal process of the `arange` function. 
+If `step = 0`, the `step` argument will be corrected to `1/1.0` by the internal process of the `arange` function.   
+If `step < 0`, the `step` argument will be corrected to `abs(by)` by the internal process of the `arange` function. 
 
 ### Return value
 
-Return a vector of fixed spaced spaced values.
+Return a one-dimensional `array` of fixed-spaced values.
 
-For `integer` type arguments, the length of the result vector is `(end - start)/by + 1`.  
-For `real` type arguments, the length of the result vector is `floor((end - start)/by) + 1`.
+For `integer` type arguments, the length of the result vector is `(end - start)/step + 1`.  
+For `real` type arguments, the length of the result vector is `floor((end - start)/step) + 1`.
 
 ### Example
 

src/Makefile.manual

@@ -150,12 +150,12 @@ stdlib_string_type.o: stdlib_ascii.o \
 stdlib_strings.o: stdlib_ascii.o \
     stdlib_string_type.o \
 	stdlib_optval.o
-stdlib_math.o: stdlib_kinds.o
+stdlib_math.o: stdlib_kinds.o \
+    stdlib_optval.o
 stdlib_math_linspace.o: \
 	stdlib_math.o
 stdlib_math_logspace.o: \
 	stdlib_math_linspace.o
 stdlib_math_arange.o: \
-    stdlib_math.o \
-    stdlib_kinds.o
+    stdlib_math.o
 stdlib_linalg_outer_product.o: stdlib_linalg.o

src/stdlib_math.fypp

@@ -4,6 +4,7 @@
 
 module stdlib_math
     use stdlib_kinds, only: int8, int16, int32, int64, sp, dp, qp
+    use stdlib_optval, only: optval
 
     implicit none
     private
@@ -264,15 +265,15 @@ module stdlib_math
 
     !> Version: experimental
     !>
-    !> `arange` creates a vector of the `integer/real` type 
-    !>  with evenly spaced values within a given interval.
+    !> `arange` creates a one-dimensional `array` of the `integer/real` type 
+    !>  with fixed-spaced values of given spacing, within a given interval.
     !> ([Specification](../page/specs/stdlib_math.html#arange))
     interface arange
         #:set RI_KINDS_TYPES = REAL_KINDS_TYPES + INT_KINDS_TYPES
         #:for k1, t1 in RI_KINDS_TYPES
-        pure module function arange_${t1[0]}$_${k1}$(start, end, by) result(result)
+        pure module function arange_${t1[0]}$_${k1}$(start, end, step) result(result)
             ${t1}$, intent(in) :: start
-            ${t1}$, intent(in), optional :: end, by
+            ${t1}$, intent(in), optional :: end, step
             ${t1}$, allocatable :: result(:)
         end function arange_${t1[0]}$_${k1}$
         #:endfor

src/stdlib_math_arange.fypp

@@ -6,47 +6,47 @@ contains
     #:for k1, t1 in REAL_KINDS_TYPES
     !> `arange` creates a vector of the `${t1}$` type 
     !>  with evenly spaced values within a given interval.
-    pure module function arange_${t1[0]}$_${k1}$(start, end, by) result(result)
+    pure module function arange_${t1[0]}$_${k1}$(start, end, step) result(result)
 
         ${t1}$, intent(in) :: start
-        ${t1}$, intent(in), optional :: end, by
+        ${t1}$, intent(in), optional :: end, step
         ${t1}$, allocatable :: result(:)
 
-        ${t1}$ :: start_, end_, by_
+        ${t1}$ :: start_, end_, step_
         integer :: i
 
         start_ = merge(start, 1.0_${k1}$, present(end))
-        end_   = merge(end,   start,      present(end))
-        by_    = sign(merge(merge(by, 1.0_${k1}$, by /= 0.0_${k1}$), &
-                 1.0_${k1}$, present(by)), end_ - start_)
+        end_   = optval(end, start)
+        step_  = optval(step, 1.0_${k1}$)
+        step_  = sign(merge(step_, 1.0_${k1}$, step_ /= 0.0_${k1}$), end_ - start_)
 
-        allocate(result(floor((end_ - start_)/by_) + 1))
+        allocate(result(floor((end_ - start_)/step_) + 1))
 
-        result = [(start_ + (i - 1)*by_, i=1, size(result), 1)]
+        result = [(start_ + (i - 1)*step_, i=1, size(result), 1)]
 
     end function arange_${t1[0]}$_${k1}$
     #:endfor
 
     #:for k1, t1 in INT_KINDS_TYPES
     !> `arange` creates a vector of the `${t1}$` type 
     !>  with evenly spaced values within a given interval.
-    pure module function arange_${t1[0]}$_${k1}$(start, end, by) result(result)
+    pure module function arange_${t1[0]}$_${k1}$(start, end, step) result(result)
 
         ${t1}$, intent(in) :: start
-        ${t1}$, intent(in), optional :: end, by
+        ${t1}$, intent(in), optional :: end, step
         ${t1}$, allocatable :: result(:)
 
-        ${t1}$ :: start_, end_, by_
+        ${t1}$ :: start_, end_, step_
         ${t1}$ :: i
 
         start_ = merge(start, 1_${k1}$, present(end))
-        end_   = merge(end,   start,    present(end))
-        by_    = sign(merge(merge(by, 1_${k1}$, by /= 0_${k1}$), &
-                 1_${k1}$, present(by) ), end_ - start_)
+        end_   = optval(end, start)
+        step_  = optval(step, 1_${k1}$)
+        step_  = sign(merge(step_, 1_${k1}$, step_ /= 0_${k1}$), end_ - start_)
 
-        allocate(result((end_ - start_)/by_ + 1))
+        allocate(result((end_ - start_)/step_ + 1))
 
-        result = [(i, i=start_, end_, by_)]
+        result = [(i, i=start_, end_, step_)]
 
     end function arange_${t1[0]}$_${k1}$
     #:endfor