[stdlib_linalg] Add zeros, ones function.

doc/specs/stdlib_linalg.md

@@ -206,3 +206,155 @@ program demo_outer_product
     !A = reshape([3., 6., 9., 4., 8., 12.], [3,2])
 end program demo_outer_product
 ```
+
+## `zeros/ones` - Create a `vector` or `matrix` of the given shape, filled completely with either `0` or `1` `integer [/real/complex]` type values
+
+### Status
+
+Experimental
+
+### Class
+
+Pure function.
+
+### Description
+
+`zeros` creates a `vector` or `matrix` of the given shape, filled completely with `0` `integer [/real/complex]` type values.  
+`ones` creates a `vector` or `matrix` of the given shape, filled completely with `1` `integer [/real/complex]` type values.
+
+### Syntax
+
+For vector:  
+`result = [[stdlib_linalg(module):zeros(interface)]](dim)`  
+`result = [[stdlib_linalg(module):ones(interface)]](dim)`
+
+For matrix:  
+`result = [[stdlib_linalg(module):zeros(interface)]](dim1, dim2)`  
+`result = [[stdlib_linalg(module):ones(interface)]](dim1, dim2)`
+
+
+### Arguments
+
+`dim/dim1`: Shall be an `integer` type.
+This is an `intent(in)` argument.
+
+`dim2`: Shall be an `integer` type.
+This is an `intent(in)` argument.
+
+#### Note
+
+Because of `huge(integer :: i) == 2147483647`, the dimensional maximum length of array created by the `zeros/ones` function is `2147483647`. 
+
+### Return value
+
+Return a `vector` or `matrix` of the given shape, filled completely with either `0` or `1` `integer [/real/complex]` type values.
+
+#### Warning
+
+If the array that receives the return value of the `zeros/ones` function is of `real/complex` type, conversion from `integer` type to `real/complex` type will occur.  
+
+Just as `Fortran` is a strongly typed statically compiled language, be careful with the following statements:
+```fortran
+real :: A(:,:)
+
+!> Be careful
+A = ones(2,2)/2     !! A = 1/2 = 0.0
+
+!> Recommend
+A = ones(2,2)/2.0   !! A = 1/2.0 = 0.5
+A = expand(0.5, 2,2)
+```
+
+### Example
+
+```fortran
+program demo
+    use stdlib_linalg, only: zeros, ones
+    implicit none
+    real, allocatable :: A(:,:)
+    integer :: iA(2)
+    compelx :: cA(2), cB(2,3)
+
+    A = zeros(2,2)          !! [0.0,0.0; 0.0,0.0]
+    A = ones(4,4)           !! [1.0,1.0,1.0,1.0; 1.0,1.0,1.0,1.0; 1.0,1.0,1.0,1.0; 1.0,1.0,1.0 1.0]
+    A = 2.0*ones(2,2)       !! [2.0,2.0; 2.0,2.0]
+
+    iA = ones(2)            !! [1,1]
+    cA = ones(2)            !! [(1.0,0.0),(1.0,0.0)]
+    cA = (1.0,1.0)*ones(2)  !! [(1.0,1.0),(1.0,1.0)]
+    cB = ones(2,3)          !! [(1.0,0.0),(1.0,0.0),(1.0,0.0); (1.0,0.0),(1.0,0.0),(1.0,0.0)]
+
+end program demo
+```
+
+## `expand` - Create a `vector` or `matrix` of the given shape, filled completely with `value` `integer/logical/real/complex/string_type` type values
+
+### Status
+
+Experimental
+
+### Class
+
+Pure function.
+
+### Description
+
+`expand` creates a `vector` or `matrix` of the given shape, filled completely with `value` `integer/logical/real/complex/string_type` type values.
+
+### Syntax
+
+For vector:  
+`result = [[stdlib_linalg(module):expand(interface)]](value, dim)`  
+
+For matrix:  
+`result = [[stdlib_linalg(module):expand(interface)]](value, dim1, dim2)`  
+
+### Arguments
+
+`value`: Shall be an `integer/logical/real/complex/string_type` scalar. 
+This is an `intent(in)` argument.
+
+`dim/dim1`: Shall be an `integer` scalar. 
+This is an `intent(in)` argument.
+
+`dim2`: Shall be an `integer` scalar. 
+This is an `intent(in)` argument.
+
+#### Note
+
+Because of `huge(integer :: i) == 2147483647`, the dimensional maximum length of array created by the `expand` function is `2147483647`. 
+
+### Return value
+
+Return a `vector` or `matrix` of the given shape, filled completely with `value` `integer/logical/real/complex/string_type` type values.
+
+### Example
+
+```fortran
+program demo_linalg_expand_1
+    use stdlib_linalg, only: expand
+    implicit none
+    real, allocatable :: A(:,:)
+
+    A = expand(0,2,2)           !! Same as zeros(2,2)
+    A = expand(1,2,1)           !! Same as ones(4,4)
+    A = 2.0*expand(1, 2,2)      !! [2.0,2.0; 2.0,2.0]
+    A = expand(1.0, 2)          !! [1.0,1.0]
+
+end program demo_linalg_expand_1
+```
+
+```fortran
+program demo_linalg_expand_2
+    use stdlib_linalg, only: expand
+    use stdlib_string_type
+    implicit none
+
+    print *, expand(1, 2)                   !! [1,1]
+    print *, expand(1.0, 2)                 !! [1.0,1.0]
+    print *, expand((1.0,1.0), 2)           !! [(1.0,1.0),(1.0,1.0)]
+    print *, expand(.false., 2)             !! [F,F]
+    print *, expand(string_type("A"), 2)    !! ["A","A"]
+
+end program demo_linalg_expand_2
+```

src/CMakeLists.txt

@@ -9,6 +9,7 @@ set(fppFiles
     stdlib_io.fypp
     stdlib_linalg.fypp
     stdlib_linalg_diag.fypp
+    stdlib_linalg_expand.fypp
     stdlib_linalg_outer_product.fypp
     stdlib_optval.fypp
     stdlib_sorting.fypp

src/Makefile.manual

@@ -6,6 +6,7 @@ SRCFYPP =\
         stdlib_io.fypp \
         stdlib_linalg.fypp \
         stdlib_linalg_diag.fypp \
+        stdlib_linalg_expand.fypp \
         stdlib_linalg_outer_product.fypp \
         stdlib_optval.fypp \
         stdlib_quadrature.fypp \
@@ -81,10 +82,15 @@ stdlib_io.o: \
 	stdlib_optval.o \
 	stdlib_kinds.o
 stdlib_linalg.o: \
-	stdlib_kinds.o
+	stdlib_kinds.o \
+    stdlib_string_type.o
 stdlib_linalg_diag.o: \
 	stdlib_linalg.o \
 	stdlib_kinds.o
+stdlib_linalg_expand.o: \
+	stdlib_linalg.o \
+	stdlib_kinds.o \
+	stdlib_string_type.o
 stdlib_logger.o: stdlib_ascii.o stdlib_optval.o
 stdlib_optval.o: stdlib_kinds.o
 stdlib_quadrature.o: stdlib_kinds.o

src/stdlib_linalg.fypp

@@ -4,14 +4,16 @@ module stdlib_linalg
   !!Provides a support for various linear algebra procedures
   !! ([Specification](../page/specs/stdlib_linalg.html))
   use stdlib_kinds, only: sp, dp, qp, &
-    int8, int16, int32, int64
+    int8, int16, int32, int64, lk, c_bool
+  use stdlib_string_type, only: string_type
   implicit none
   private
 
   public :: diag
   public :: eye
   public :: trace
   public :: outer_product
+  public :: zeros, ones, expand
 
   interface diag
     !! version: experimental
@@ -80,6 +82,66 @@ module stdlib_linalg
     #:endfor
   end interface outer_product
 
+    !> Version: experimental
+    !>
+    !> `ones` creates a vector or matrix of the given shape, 
+    !>  filled completely with `1` `integer` type values. 
+    !> ([Specification](../page/specs/stdlib_linalg.html#
+    !>zerosones-create-a-vector-or-matrix-of-the-given-shape
+    !>-filled-completely-with-either-0-or-1-integer-realcomplex-type-values))
+    interface ones
+        pure module function ones_1_default(dim) result(result)
+            integer, intent(in) :: dim
+            integer, allocatable :: result(:)
+        end function ones_1_default
+        pure module function ones_2_default(dim1, dim2) result(result)
+            integer, intent(in) :: dim1, dim2
+            integer, allocatable :: result(:, :)
+        end function ones_2_default
+    end interface ones
+
+    !> Version: experimental
+    !>
+    !> `zeros` creates a vector or matrix of the given shape, 
+    !>  filled completely with `0` `integer` type values. 
+    !> ([Specification](../page/specs/stdlib_linalg.html#
+    !>zerosones-create-a-vector-or-matrix-of-the-given-shape
+    !>-filled-completely-with-either-0-or-1-integer-realcomplex-type-values))
+    interface zeros
+        pure module function zeros_1_default(dim) result(result)
+            integer, intent(in) :: dim
+            integer, allocatable :: result(:)
+        end function zeros_1_default
+        pure module function zeros_2_default(dim1, dim2) result(result)
+            integer, intent(in) :: dim1, dim2
+            integer, allocatable :: result(:, :)
+        end function zeros_2_default
+    end interface zeros
+
+    !> Version: experimental
+    !>
+    !> `expand` creates a vector or matrix of the given shape, 
+    !>  filled with `value` `integer/logical/real/complex/string_type` type values.
+    !> ([Specification](../page/specs/stdlib_linalg.html#
+    !>expand-create-a-vector-or-matrix-of-the-given-shape-
+    !>filled-completely-with-value-integerlogicalrealcomplexstring_type-type-values))
+    interface expand
+        #:set ALL_KINDS_TYPES = REAL_KINDS_TYPES + INT_KINDS_TYPES + CMPLX_KINDS_TYPES &
+            & + LOG_KINDS_TYPES + STRING_KINDS_TYPES
+        #:for k1, t1 in ALL_KINDS_TYPES
+        pure module function expand_1_${t1[0]}$_${k1}$(value, dim) result(result)
+            ${t1}$, intent(in) :: value
+            integer, intent(in) :: dim
+            ${t1}$, allocatable :: result(:)
+        end function expand_1_${t1[0]}$_${k1}$
+        pure module function expand_2_${t1[0]}$_${k1}$(value, dim1, dim2) result(result)
+            ${t1}$, intent(in) :: value
+            integer, intent(in) :: dim1, dim2
+            ${t1}$, allocatable :: result(:, :)
+        end function expand_2_${t1[0]}$_${k1}$
+        #:endfor
+    end interface expand
+
 contains
 
     function eye(n) result(res)
@@ -108,4 +170,5 @@ contains
         end do
       end function trace_${t1[0]}$${k1}$
     #:endfor
-end module
+
+end module stdlib_linalg

src/stdlib_linalg_expand.fypp

@@ -0,0 +1,74 @@
+#:include "common.fypp"
+#:set ALL_KINDS_TYPES = REAL_KINDS_TYPES + INT_KINDS_TYPES + CMPLX_KINDS_TYPES &
+    & + LOG_KINDS_TYPES + STRING_KINDS_TYPES
+submodule(stdlib_linalg) stdlib_linalg_expand
+
+contains
+
+    !> `ones` creates a vector, filled completely with `1` `integer` type values.
+    pure module function ones_1_default(dim) result(result)
+        integer, intent(in) :: dim
+        integer, allocatable :: result(:)
+
+        allocate(result(dim))
+        result = 1
+
+    end function ones_1_default
+
+    !> `ones` creates a matrix, filled completely with `1` `integer` type values.
+    pure module function ones_2_default(dim1, dim2) result(result)
+        integer, intent(in) :: dim1, dim2
+        integer, allocatable :: result(:, :)
+
+        allocate(result(dim1, dim2))
+        result = 1
+
+    end function ones_2_default
+
+    !> `zeros` creates a vector, filled completely with `0` `integer` type values.
+    pure module function zeros_1_default(dim) result(result)
+        integer, intent(in) :: dim
+        integer, allocatable :: result(:)
+
+        allocate(result(dim))
+        result = 0
+
+    end function zeros_1_default
+
+    !> `zeros` creates a matrix, filled completely with `0` `integer` type values.
+    pure module function zeros_2_default(dim1, dim2) result(result)
+        integer, intent(in) :: dim1, dim2
+        integer, allocatable :: result(:, :)
+
+        allocate(result(dim1, dim2))
+        result = 0
+
+    end function zeros_2_default
+
+    #:for k1, t1 in ALL_KINDS_TYPES
+    !> `expand` creates a vector, filled completely with `value` `${t1}$` type values.
+    pure module function expand_1_${t1[0]}$_${k1}$(value, dim) result(result)
+
+        ${t1}$, intent(in) :: value
+        integer, intent(in) :: dim
+        ${t1}$, allocatable :: result(:)
+
+        allocate(result(dim))
+        result = value
+
+    end function expand_1_${t1[0]}$_${k1}$
+
+    !> `expand` creates a matrix, filled completely with `value` `${t1}$` type values.
+    pure module function expand_2_${t1[0]}$_${k1}$(value, dim1, dim2) result(result)
+
+        ${t1}$, intent(in) :: value
+        integer, intent(in) :: dim1, dim2
+        ${t1}$, allocatable :: result(:, :)
+
+        allocate(result(dim1, dim2))
+        result = value
+
+    end function expand_2_${t1[0]}$_${k1}$
+    #:endfor
+
+end submodule stdlib_linalg_expand

src/tests/Makefile.manual

@@ -11,3 +11,4 @@ all test clean:
 	$(MAKE) -f Makefile.manual --directory=stats $@
 	$(MAKE) -f Makefile.manual --directory=string $@
 	$(MAKE) -f Makefile.manual --directory=math $@
+	$(MAKE) -f Makefile.manual --directory=linalg $@

src/tests/linalg/CMakeLists.txt

@@ -1,2 +1,3 @@
 ADDTEST(linalg)
+ADDTEST(linalg_expand)
 

src/tests/linalg/Makefile.manual

@@ -0,0 +1,4 @@
+PROGS_SRC = test_linalg_expand.f90
+
+
+include ../Makefile.manual.test.mk