Merge branch 'master' of https://github.com/fortran-lang/stdlib into string-list-new

Author: aman-godara

doc/specs/stdlib_linalg.md

@@ -168,3 +168,41 @@ program demo_trace
     print *, trace(A) ! 1 + 5 + 9
 end program demo_trace
 ```
+
+## `outer_product` - Computes the outer product of two vectors
+
+### Status
+
+Experimental
+
+### Description
+
+Computes the outer product of two vectors
+
+### Syntax
+
+`d = [[stdlib_linalg(module):outer_product(interface)]](u, v)`
+
+### Arguments
+
+`u`: Shall be a rank-1 array
+
+`v`: Shall be a rank-1 array
+
+### Return value
+
+Returns a rank-2 array equal to `u v^T` (where `u, v` are considered column vectors). The shape of the returned array is `[size(u), size(v)]`.
+
+### Example
+
+```fortran
+program demo_outer_product
+    use stdlib_linalg, only: outer_product
+    implicit none
+    real, allocatable :: A(:,:), u(:), v(:)
+    u = [1., 2., 3. ]
+    v = [3., 4.]
+    A = outer_product(u,v)
+    !A = reshape([3., 6., 9., 4., 8., 12.], [3,2])
+end program demo_outer_product
+```

doc/specs/stdlib_quadrature.md

@@ -186,3 +186,95 @@ program demo_simps_weights
 ! 64.0
 end program demo_simps_weights
 ```
+
+## `gauss_legendre` - Gauss-Legendre quadrature (a.k.a. Gaussian quadrature) nodes and weights
+
+### Status
+
+Experimental
+
+### Description
+
+Computes Gauss-Legendre quadrature (also known as simply Gaussian quadrature) nodes and weights,
+ for any `N` (number of nodes).
+Using the nodes `x` and weights `w`, you can compute the integral of some function `f` as follows:
+`integral = sum(f(x) * w)`.
+
+Only double precision is supported - if lower precision is required, you must do the appropriate conversion yourself.
+Accuracy has been validated up to N=64 by comparing computed results to tablulated values known to be accurate to machine precision
+(maximum difference from those values is 2 epsilon).
+
+### Syntax
+
+`subroutine [[stdlib_quadrature(module):gauss_legendre(interface)]] (x, w[, interval])`
+
+### Arguments
+
+`x`: Shall be a rank-one array of type `real(real64)`. It is an *output* argument, representing the quadrature nodes.
+
+`w`: Shall be a rank-one array of type `real(real64)`, with the same dimension as `x`. 
+It is an *output* argument, representing the quadrature weights.
+
+`interval`: (Optional) Shall be a two-element array of type `real(real64)`. 
+If present, the nodes and weigts are calculated for integration from `interval(1)` to `interval(2)`.
+If not specified, the default integral is -1 to 1.
+
+### Example
+
+```fortran
+program integrate
+	use iso_fortran_env, dp => real64
+	implicit none
+
+	integer, parameter :: N = 6
+	real(dp), dimension(N) :: x,w
+	call gauss_legendre(x,w)
+	print *, "integral of x**2 from -1 to 1 is",  sum(x**2 * w)
+end program
+```
+
+## `gauss_legendre_lobatto` - Gauss-Legendre-Lobatto quadrature nodes and weights
+
+### Status
+
+Experimental
+
+### Description
+
+Computes Gauss-Legendre-Lobatto quadrature nodes and weights,
+ for any `N` (number of nodes).
+Using the nodes `x` and weights `w`, you can compute the integral of some function `f` as follows:
+`integral = sum(f(x) * w)`.
+
+Only double precision is supported - if lower precision is required, you must do the appropriate conversion yourself.
+Accuracy has been validated up to N=64 by comparing computed results to tablulated values known to be accurate to machine precision
+(maximum difference from those values is 2 epsilon).
+
+### Syntax
+
+`subroutine [[stdlib_quadrature(module):gauss_legendre_lobatto(interface)]] (x, w[, interval])`
+
+### Arguments
+
+`x`: Shall be a rank-one array of type `real(real64)`. It is an *output* argument, representing the quadrature nodes.
+
+`w`: Shall be a rank-one array of type `real(real64)`, with the same dimension as `x`. 
+It is an *output* argument, representing the quadrature weights.
+
+`interval`: (Optional) Shall be a two-element array of type `real(real64)`. 
+If present, the nodes and weigts are calculated for integration from `interval(1)` to `interval(2)`.
+If not specified, the default integral is -1 to 1.
+
+### Example
+
+```fortran
+program integrate
+	use iso_fortran_env, dp => real64
+	implicit none
+
+	integer, parameter :: N = 6
+	real(dp), dimension(N) :: x,w
+	call gauss_legendre_lobatto(x,w)
+	print *, "integral of x**2 from -1 to 1 is",  sum(x**2 * w)
+end program
+```

doc/specs/stdlib_specialfunctions.md

@@ -0,0 +1,63 @@
+---
+title: specialfunctions
+---
+
+# Special functions
+
+[TOC]
+
+## `legendre` - Calculate Legendre polynomials
+
+### Status
+
+Experimental
+
+### Description
+
+Computes the value of the n-th Legendre polynomial at a specified point.
+Currently only 64 bit floating point is supported.
+
+This is an `elemental` function.
+
+### Syntax
+
+`result = [[stdlib_specialfunctions(module):legendre(interface)]] (n, x)`
+
+### Arguments
+
+`n`: Shall be a scalar of type `real(real64)`. 
+
+`x`: Shall be a scalar or array (this function is elemental) of type `real(real64)`. 
+
+### Return value
+
+The function result will be the value of the `n`-th Legendre polynomial, evaluated at `x`.
+
+
+
+## `dlegendre` - Calculate first derivatives of Legendre polynomials
+
+### Status
+
+Experimental
+
+### Description
+
+Computes the value of the first derivative of the n-th Legendre polynomial at a specified point.
+Currently only 64 bit floating point is supported.
+
+This is an `elemental` function.
+
+### Syntax
+
+`result = [[stdlib_specialfunctions(module):dlegendre(interface)]] (n, x)`
+
+### Arguments
+
+`n`: Shall be a scalar of type `real(real64)`. 
+
+`x`: Shall be a scalar or array (this function is elemental) of type `real(real64)`. 
+
+### Return value
+
+The function result will be the value of the first derivative of the `n`-th Legendre polynomial, evaluated at `x`.

src/CMakeLists.txt

@@ -9,6 +9,7 @@ set(fppFiles
     stdlib_io.fypp
     stdlib_linalg.fypp
     stdlib_linalg_diag.fypp
+    stdlib_linalg_outer_product.fypp
     stdlib_optval.fypp
     stdlib_sorting.fypp
     stdlib_sorting_ord_sort.fypp
@@ -49,6 +50,9 @@ set(SRC
     stdlib_logger.f90
     stdlib_strings.f90
     stdlib_system.F90
+    stdlib_specialfunctions.f90
+    stdlib_specialfunctions_legendre.f90
+    stdlib_quadrature_gauss.f90
     ${outFiles}
 )
 

src/Makefile.manual

@@ -6,6 +6,7 @@ SRCFYPP =\
         stdlib_io.fypp \
         stdlib_linalg.fypp \
         stdlib_linalg_diag.fypp \
+        stdlib_linalg_outer_product.fypp \
         stdlib_optval.fypp \
         stdlib_quadrature.fypp \
         stdlib_quadrature_trapz.fypp \
@@ -29,8 +30,12 @@ SRCFYPP =\
 
 SRC = f18estop.f90 \
       stdlib_error.f90 \
+      stdlib_specialfunctions.f90 \
+      stdlib_specialfunctions_legendre.f90 \
+      stdlib_io.f90 \
       stdlib_kinds.f90 \
       stdlib_logger.f90 \
+      stdlib_quadrature_gauss.f90 \
       stdlib_strings.f90 \
       $(SRCGEN)
 
@@ -65,6 +70,8 @@ stdlib_bitsets.o: stdlib_kinds.o
 stdlib_bitsets_64.o: stdlib_bitsets.o
 stdlib_bitsets_large.o: stdlib_bitsets.o
 stdlib_error.o: stdlib_optval.o
+stdlib_specialfunctions.o: stdlib_kinds.o
+stdlib_specialfunctions_legendre.o: stdlib_kinds.o stdlib_specialfunctions.o
 stdlib_io.o: \
 	stdlib_error.o \
 	stdlib_optval.o \
@@ -77,6 +84,9 @@ stdlib_linalg_diag.o: \
 stdlib_logger.o: stdlib_ascii.o stdlib_optval.o
 stdlib_optval.o: stdlib_kinds.o
 stdlib_quadrature.o: stdlib_kinds.o
+
+stdlib_quadrature_gauss.o: stdlib_kinds.o stdlib_quadrature.o
+
 stdlib_quadrature_simps.o: \
 	stdlib_quadrature.o \
 	stdlib_error.o \
@@ -131,3 +141,4 @@ stdlib_strings.o: stdlib_ascii.o \
     stdlib_string_type.o \
 	stdlib_optval.o
 stdlib_math.o: stdlib_kinds.o
+stdlib_linalg_outer_product.o: stdlib_linalg.o

src/stdlib_linalg.fypp

@@ -11,6 +11,7 @@ module stdlib_linalg
   public :: diag
   public :: eye
   public :: trace
+  public :: outer_product
 
   interface diag
     !! version: experimental
@@ -52,6 +53,7 @@ module stdlib_linalg
     #:endfor
   end interface
 
+
   ! Matrix trace
   interface trace
     !! version: experimental
@@ -63,6 +65,21 @@ module stdlib_linalg
     #:endfor
   end interface
 
+
+  ! Outer product (of two vectors)
+  interface outer_product
+    !! version: experimental
+    !!
+    !! Computes the outer product of two vectors, returning a rank-2 array
+    !! ([Specification](../page/specs/stdlib_linalg.html#description_3))
+    #:for k1, t1 in RCI_KINDS_TYPES
+      pure module function outer_product_${t1[0]}$${k1}$(u, v) result(res)
+        ${t1}$, intent(in) :: u(:), v(:)
+        ${t1}$ :: res(size(u),size(v))
+      end function outer_product_${t1[0]}$${k1}$
+    #:endfor
+  end interface outer_product
+
 contains
 
     function eye(n) result(res)

src/stdlib_linalg_outer_product.fypp

@@ -0,0 +1,20 @@
+#:include "common.fypp"
+#:set RCI_KINDS_TYPES = REAL_KINDS_TYPES + CMPLX_KINDS_TYPES + INT_KINDS_TYPES
+submodule (stdlib_linalg) stdlib_linalg_outer_product
+
+  implicit none
+
+contains
+
+  #:for k1, t1 in RCI_KINDS_TYPES
+    pure module function outer_product_${t1[0]}$${k1}$(u, v) result(res)
+      ${t1}$, intent(in) :: u(:), v(:)
+      ${t1}$ :: res(size(u),size(v))
+      integer :: col
+      do col = 1, size(v)
+        res(:,col) = v(col) * u
+      end do
+    end function outer_product_${t1[0]}$${k1}$
+  #:endfor
+
+end submodule

src/stdlib_quadrature.fypp

@@ -12,6 +12,8 @@ module stdlib_quadrature
     public :: trapz_weights
     public :: simps
     public :: simps_weights
+    public :: gauss_legendre
+    public :: gauss_legendre_lobatto
 
 
     interface trapz
@@ -90,6 +92,28 @@ module stdlib_quadrature
     end interface simps_weights
 
 
+    interface gauss_legendre
+        !! version: experimental
+        !!
+        !! Computes Gauss-Legendre quadrature nodes and weights.
+        pure module subroutine gauss_legendre_fp64 (x, w, interval)
+            real(dp), intent(out) :: x(:), w(:)
+            real(dp), intent(in), optional :: interval(2)
+        end subroutine
+    end interface gauss_legendre
+
+
+    interface gauss_legendre_lobatto
+        !! version: experimental
+        !!
+        !! Computes Gauss-Legendre-Lobatto quadrature nodes and weights.
+        pure module subroutine gauss_legendre_lobatto_fp64 (x, w, interval)
+            real(dp), intent(out) :: x(:), w(:)
+            real(dp), intent(in), optional :: interval(2)
+        end subroutine
+    end interface gauss_legendre_lobatto
+
+
     ! Interface for a simple f(x)-style integrand function.
     ! Could become fancier as we learn about the performance
     ! ramifications of different ways to do callbacks.
@@ -103,4 +127,6 @@ module stdlib_quadrature
         #:endfor
     end interface
 
+
+
 end module stdlib_quadrature