All specs + minor modifs.

Author: loiseaujc

doc/specs/stdlib_linalg.md

@@ -955,6 +955,32 @@ where \(A\) is an \( m \times n \) matrix (with \(m \geq n\)) and \(C\) a \( p
 {!example/linalg/example_constrained_lstsq2.f90!}
 ```
 
+## `constrained_lstsq_space` - Compute internal workspace requirements for the constrained least-square solver {#constrained-lstsq-space}
+
+### Status
+
+Experimental
+
+### Description
+
+This subroutine computes the internal workspace requirements for the constrained least-squares solver, [stdlib_linalg(module):solve_constrained_lstsq(interface)].
+
+### Syntax
+
+call [stdlib_linalg(module):constrained_lstsq_space(interface)]`(a,  c,  lwork [, err])`
+
+### Arguments
+
+`a`: Shall be a rank-2 `real` or `complex` array used in the definition of the least-squares cost. It is an `intent(in)` argument.
+
+`b`: Shall be a rank-1 array of the same kind as `a` appearing in the definition of the least-squares cost. It is an `intent(in)` argument.
+
+`c`: Shall be a rank-2 `real` or `complex` array of the same kind as `a` defining the linear equality constraints. It is an `intent(in)` argument.
+
+`d`: Shall be a rank-1 array of the same kind as `a` appearing in the definition of the linear equality constraints.
+
+`lwork`: Shall be an `interger` scalar returning the optimal size required for the workspace array to solve the constrained least-squares problem.
+
 ## `det` - Computes the determinant of a square matrix
 
 ### Status

example/linalg/example_constrained_lstsq2.f90

@@ -31,7 +31,7 @@ program example_constrained_lstsq2
    d = [1.0_dp, 3.0_dp, -1.0_dp]
 
    !> Optimal workspace size.
-   call constrained_lstsq_space(A, b, C, d, lwork)
+   call constrained_lstsq_space(A, C, lwork)
    allocate (work(lwork))
 
    ! Compute the solution.

src/stdlib_linalg.fypp

@@ -668,11 +668,11 @@ module stdlib_linalg
     !!  working arrays are provided, no internal allocation will take place.
     !!
     #:for rk, rt, ri in RC_KINDS_TYPES
-    module subroutine stdlib_linalg_${ri}$_constrained_lstsq_space(A, b, C, d, lwork, err)
+    module subroutine stdlib_linalg_${ri}$_constrained_lstsq_space(A, C, lwork, err)
         !> Least-squares cost.
-        ${rt}$, intent(in) :: A(:, :), b(:)
+        ${rt}$, intent(in) :: A(:, :)
         !> Equality constraints.
-        ${rt}$, intent(in) :: C(:, :), d(:)
+        ${rt}$, intent(in) :: C(:, :)
         integer(ilp), intent(out) :: lwork
         type(linalg_state_type), optional, intent(out) :: err
     end subroutine stdlib_linalg_${ri}$_constrained_lstsq_space

src/stdlib_linalg_least_squares.fypp

@@ -390,11 +390,11 @@ submodule (stdlib_linalg) stdlib_linalg_least_squares
 
     #:for rk, rt, ri in RC_KINDS_TYPES
     ! Compute the size of the workspace requested by the constrained least-squares procedure.
-    module subroutine stdlib_linalg_${ri}$_constrained_lstsq_space(A, b, C, d, lwork, err)
+    module subroutine stdlib_linalg_${ri}$_constrained_lstsq_space(A, C, lwork, err)
         !> Least-squares cost.
-        ${rt}$, intent(in) :: A(:, :), b(:)
+        ${rt}$, intent(in) :: A(:, :)
         !> Equality constraints.
-        ${rt}$, intent(in) :: C(:, :), d(:)
+        ${rt}$, intent(in) :: C(:, :)
         !> Size of the workspace array.
         integer(ilp), intent(out)  :: lwork
         !> [optional] State return flag.
@@ -492,7 +492,7 @@ submodule (stdlib_linalg) stdlib_linalg_least_squares
         endif
 
         !> Retrieve workspace size.
-        call stdlib_linalg_${ri}$_constrained_lstsq_space(A, b, C, d, lwork, err0)
+        call stdlib_linalg_${ri}$_constrained_lstsq_space(A, C, lwork, err0)
 
         if (err0%ok()) then
             !> Workspace.

test/linalg/test_linalg_constrained_lstsq.fypp

@@ -79,7 +79,7 @@ module test_linalg_constrained_least_squares
         if (allocated(error)) return
 
         !----- Pre-allocated storage -----
-        call constrained_lstsq_space(A, b, C, d, lwork, err=state)
+        call constrained_lstsq_space(A, C, lwork, err=state)
         call check(error, state%ok(), state%print())
         if (allocated(error)) return
         allocate(work(lwork))