vector_math.f90

Go to the documentation of this file.

! Copyright (c) 2008-2020, UCHICAGO ARGONNE, LLC.
!
! The UChicago Argonne, LLC as Operator of Argonne National
! Laboratory holds copyright in the Software. The copyright holder
! reserves all rights except those expressly granted to licensees,
! and U.S. Government license rights.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
! 1. Redistributions of source code must retain the above copyright
! notice, this list of conditions and the disclaimer below.
!
! 2. Redistributions in binary form must reproduce the above copyright
! notice, this list of conditions and the disclaimer (as noted below)
! in the documentation and/or other materials provided with the
! distribution.
!
! 3. Neither the name of ANL nor the names of its contributors
! may be used to endorse or promote products derived from this software
! without specific prior written permission.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL
! UCHICAGO ARGONNE, LLC, THE U.S. DEPARTMENT OF
! ENERGY OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
! SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
! TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
! DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
! THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
! OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
!
! Additional BSD Notice
! ---------------------
! 1. This notice is required to be provided under our contract with
! the U.S. Department of Energy (DOE). This work was produced at
! Argonne National Laboratory under Contract
! No. DE-AC02-06CH11357 with the DOE.
!
! 2. Neither the United States Government nor UCHICAGO ARGONNE,
! LLC nor any of their employees, makes any warranty,
! express or implied, or assumes any liability or responsibility for the
! accuracy, completeness, or usefulness of any information, apparatus,
! product, or process disclosed, or represents that its use would not
! infringe privately-owned rights.
!
! 3. Also, reference herein to any specific commercial products, process,
! or services by trade name, trademark, manufacturer or otherwise does
! not necessarily constitute or imply its endorsement, recommendation,
! or favoring by the United States Government or UCHICAGO ARGONNE LLC.
! The views and opinions of authors expressed
! herein do not necessarily state or reflect those of the United States
! Government or UCHICAGO ARGONNE, LLC, and shall
! not be used for advertising or product endorsement purposes.
!
module vector_math
  use neko_config, only : neko_bcknd_device
  use num_types, only : rp
  use vector, only : vector_t
  use mask, only : mask_t
  use device, only : device_get_ptr
  use utils, only : neko_error
  use math, only : rzero, rone, copy, cmult, cadd, cfill, invcol1, vdot3, &
       add2, add3, add4, sub2, sub3, add2s1, add2s2, addsqr2s2, cmult2, &
       invcol2, col2, col3, subcol3, add3s2, addcol3, addcol4, glsum, glmax, &
       glmin, glsc2, glsc3, masked_gather_copy_0, face_masked_gather_copy_0, &
       masked_gather_copy, cadd2, masked_scatter_copy, &
       masked_scatter_copy_0, glsubnorm, invcol3, cwrap, &
       sqrt_inplace, power, absval
  use device_math, only : device_rzero, device_rone, device_copy, &
       device_cmult, device_cadd, device_cfill, device_invcol1, device_vdot3, &
       device_cadd2, device_absval, &
       device_add2, device_add3, device_add4, device_sub2, device_sub3, &
       device_add2s1, device_add2s2, device_addsqr2s2, device_cmult2, &
       device_invcol2, device_col2, device_col3, device_subcol3, &
       device_add3s2, device_addcol3, device_addcol4, device_glsum, &
       device_glmax, device_glmin, device_glsc2, device_glsc3, &
       device_masked_gather_copy_0, device_face_masked_gather_copy_0, &
       device_masked_gather_copy_aligned, device_masked_scatter_copy_0, &
       device_masked_scatter_copy_aligned, device_glsubnorm, device_invcol3, &
       device_cwrap, device_sqrt_inplace, device_power
  use, intrinsic :: iso_c_binding, only : c_ptr
  implicit none
  private
 
  public :: vector_rzero, vector_rone, vector_copy, vector_cmult, &
       vector_cadd, vector_cfill, vector_invcol1, vector_invcol3, &
       vector_vdot3, vector_cadd2, vector_absval, &
       vector_add2, vector_sub2, vector_sub3, vector_add2s1, &
       vector_add2s2, vector_addsqr2s2, vector_cmult2, &
       vector_invcol2, vector_col2, vector_col3, vector_subcol3, &
       vector_add3s2, vector_addcol3, vector_addcol4, vector_glsum, &
       vector_glmax, vector_glmin, vector_glsc2, vector_glsc3, vector_add3, &
       vector_masked_gather_copy_0, vector_face_masked_gather_copy_0, &
       vector_masked_gather_copy, vector_masked_scatter_copy_0, &
       vector_masked_scatter_copy, vector_glsubnorm, vector_cwrap, &
       vector_sqrt_inplace, vector_power
 
contains
 
  subroutine vector_rzero(a, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_rzero(a%x_d, size)
    else
       call rzero(a%x, size)
    end if
  end subroutine vector_rzero
 
  subroutine vector_rone(a, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_rone(a%x_d, size)
    else
       call rone(a%x, size)
    end if
  end subroutine vector_rone
 
  subroutine vector_copy(a, b, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: b
    type(vector_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_copy(a%x_d, b%x_d, size)
    else
       call copy(a%x, b%x, size)
    end if
  end subroutine vector_copy
 
  subroutine vector_cmult(a, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    real(kind=rp), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cmult(a%x_d, c, size)
    else
       call cmult(a%x, c, size)
    end if
  end subroutine vector_cmult
 
  subroutine vector_cadd(a, s, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    real(kind=rp), intent(in) :: s
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cadd(a%x_d, s, size)
    else
       call cadd(a%x, s, size)
    end if
  end subroutine vector_cadd
 
  subroutine vector_cadd2(a, b, s, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    real(kind=rp), intent(in) :: s
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cadd2(a%x_d, b%x_d, s, size)
    else
       call cadd2(a%x, b%x, s, size)
    end if
  end subroutine vector_cadd2
 
 
  subroutine vector_cfill(a, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    real(kind=rp), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cfill(a%x_d, c, size)
    else
       call cfill(a%x, c, size)
    end if
  end subroutine vector_cfill
 
  subroutine vector_invcol1(a, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_invcol1(a%x_d, size)
    else
       call invcol1(a%x, size)
    end if
 
  end subroutine vector_invcol1
 
  subroutine vector_invcol3(a, b, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(vector_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_invcol3(a%x_d, b%x_d, c%x_d, size)
    else
       call invcol3(a%x, b%x, c%x, size)
    end if
 
  end subroutine vector_invcol3
 
  subroutine vector_vdot3(dot, u1, u2, u3, v1, v2, v3, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: u1, u2, u3
    type(vector_t), intent(in) :: v1, v2, v3
    type(vector_t), intent(inout) :: dot
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = dot%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_vdot3(dot%x_d, &
            u1%x_d, u2%x_d, u3%x_d, &
            v1%x_d, v2%x_d, v3%x_d, &
            size)
    else
       call vdot3(dot%x, &
            u1%x, u2%x, u3%x, &
            v1%x, v2%x, v3%x, &
            size)
    end if
 
  end subroutine vector_vdot3
 
  subroutine vector_add2(a, b, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add2(a%x_d, b%x_d, size)
    else
       call add2(a%x, b%x, size)
    end if
 
  end subroutine vector_add2
 
  subroutine vector_add3(a, b, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b, c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add3(a%x_d, b%x_d, c%x_d, size)
    else
       call add3(a%x, b%x, c%x, size)
    end if
 
  end subroutine vector_add3
 
  subroutine vector_add4(a, b, c, d, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b, c, d
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add4(a%x_d, b%x_d, c%x_d, d%x_d, size)
    else
       call add4(a%x, b%x, c%x, d%x, size)
    end if
 
  end subroutine vector_add4
 
  subroutine vector_sub2(a, b, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(inout) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_sub2(a%x_d, b%x_d, size)
    else
       call sub2(a%x, b%x, size)
    end if
 
  end subroutine vector_sub2
 
  subroutine vector_sub3(a, b, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(vector_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_sub3(a%x_d, b%x_d, c%x_d, size)
    else
       call sub3(a%x, b%x, c%x, size)
    end if
 
  end subroutine vector_sub3
 
 
  subroutine vector_add2s1(a, b, c1, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(inout) :: b
    real(kind=rp), intent(in) :: c1
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add2s1(a%x_d, b%x_d, c1, size)
    else
       call add2s1(a%x, b%x, c1, size)
    end if
 
  end subroutine vector_add2s1
 
  subroutine vector_add2s2(a, b, c1, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    real(kind=rp), intent(in) :: c1
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add2s2(a%x_d, b%x_d, c1, size)
    else
       call add2s2(a%x, b%x, c1, size)
    end if
 
  end subroutine vector_add2s2
 
  subroutine vector_addsqr2s2(a, b, c1, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    real(kind=rp), intent(in) :: c1
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_addsqr2s2(a%x_d, b%x_d, c1, size)
    else
       call addsqr2s2(a%x, b%x, c1, size)
    end if
 
  end subroutine vector_addsqr2s2
 
  subroutine vector_cmult2(a, b, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    real(kind=rp), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_cmult2(a%x_d, b%x_d, c, size)
    else
       call cmult2(a%x, b%x, c, size)
    end if
 
  end subroutine vector_cmult2
 
  subroutine vector_invcol2(a, b, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_invcol2(a%x_d, b%x_d, size)
    else
       call invcol2(a%x, b%x, size)
    end if
 
  end subroutine vector_invcol2
 
 
  subroutine vector_col2(a, b, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_col2(a%x_d, b%x_d, size)
    else
       call col2(a%x, b%x, size)
    end if
 
  end subroutine vector_col2
 
  subroutine vector_col3(a, b, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(vector_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_col3(a%x_d, b%x_d, c%x_d, size)
    else
       call col3(a%x, b%x, c%x, size)
    end if
 
  end subroutine vector_col3
 
  subroutine vector_subcol3(a, b, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(vector_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_subcol3(a%x_d, b%x_d, c%x_d, size)
    else
       call subcol3(a%x, b%x, c%x, size)
    end if
 
  end subroutine vector_subcol3
 
  subroutine vector_add3s2(a, b, c, c1, c2, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(vector_t), intent(in) :: c
    real(kind=rp), intent(in) :: c1, c2
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_add3s2(a%x_d, b%x_d, c%x_d, c1, c2, size)
    else
       call add3s2(a%x, b%x, c%x, c1, c2, size)
    end if
 
  end subroutine vector_add3s2
 
  subroutine vector_addcol3(a, b, c, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(vector_t), intent(in) :: c
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_addcol3(a%x_d, b%x_d, c%x_d, size)
    else
       call addcol3(a%x, b%x, c%x, size)
    end if
 
  end subroutine vector_addcol3
 
  subroutine vector_addcol4(a, b, c, d, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(vector_t), intent(in) :: c
    type(vector_t), intent(in) :: d
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_addcol4(a%x_d, b%x_d, c%x_d, d%x_d, size)
    else
       call addcol4(a%x, b%x, c%x, d%x, size)
    end if
 
  end subroutine vector_addcol4
 
  function vector_glsum(a, n) result(sum)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: a
    real(kind=rp) :: sum
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       sum = device_glsum(a%x_d, size)
    else
       sum = glsum(a%x, size)
    end if
 
  end function vector_glsum
 
  function vector_glmax(a, n) result(val)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: a
    real(kind=rp) :: val
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       val = device_glmax(a%x_d, size)
    else
       val = glmax(a%x, size)
    end if
 
  end function vector_glmax
 
  function vector_glmin(a, n) result(val)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: a
    real(kind=rp) :: val
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       val = device_glmin(a%x_d, size)
    else
       val = glmin(a%x, size)
    end if
 
  end function vector_glmin
 
  function vector_glsc2(a, b, n) result(norm)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: a, b
    real(kind=rp) :: norm
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       norm = device_glsc2(a%x_d, b%x_d, size)
    else
       norm = glsc2(a%x, b%x, size)
    end if
 
  end function vector_glsc2
 
  function vector_glsc3(a, b, c, n) result(norm)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: a, b, c
    real(kind=rp) :: norm
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       norm = device_glsc3(a%x_d, b%x_d, c%x_d, size)
    else
       norm = glsc3(a%x, b%x, c%x, size)
    end if
 
  end function vector_glsc3
 
  subroutine vector_absval(a, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_absval(a%x_d, size)
    else
       call absval(a%x, size)
    end if
 
  end subroutine vector_absval
 
  function vector_glsubnorm(a, b, n) result(norm)
    integer, intent(in), optional :: n
    type(vector_t), intent(in) :: a, b
    real(kind=rp) :: norm
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       norm = device_glsubnorm(a%x_d, b%x_d, size)
    else
       norm = glsubnorm(a%x, b%x, size)
    end if
 
  end function vector_glsubnorm
 
  subroutine vector_masked_gather_copy_0(a, b, mask, n, n_mask)
    integer, intent(in) :: n, n_mask
    type(vector_t), intent(inout) :: a
    real(kind=rp), dimension(n), intent(in) :: b
    integer, dimension(0:n_mask) :: mask
    type(c_ptr) :: mask_d, b_d
 
    if (n .lt. 1 .or. n_mask .lt. 1) return !Avoid getting null pointers
 
    if (neko_bcknd_device .eq. 1) then
       mask_d = device_get_ptr(mask)
       b_d = device_get_ptr(b)
       call device_masked_gather_copy_0(a%x_d, b_d, mask_d, n, n_mask)
    else
       call masked_gather_copy_0(a%x, b, mask, n, n_mask)
    end if
 
  end subroutine vector_masked_gather_copy_0
 
  subroutine vector_face_masked_gather_copy_0(a, b, mask, facet, lx, ly, lz, &
       n_mask)
    integer, intent(in) :: lx, ly, lz, n_mask
    type(vector_t), intent(inout) :: a
    real(kind=rp), dimension(:, :, :, :), intent(in) :: b
    integer, dimension(0:n_mask), intent(in) :: mask
    integer, dimension(0:n_mask), intent(in) :: facet
    type(c_ptr) :: mask_d, facet_d, b_d
 
    if (neko_bcknd_device .eq. 1) then
       mask_d = device_get_ptr(mask)
       facet_d = device_get_ptr(facet)
       b_d = device_get_ptr(b)
       call device_face_masked_gather_copy_0(a%x_d, b_d, mask_d, facet_d, &
            size(b, 1), size(b, 2), lx, ly, lz, n_mask)
    else
       call face_masked_gather_copy_0(a%x, b, mask, facet, lx, ly, lz, n_mask)
    end if
 
  end subroutine vector_face_masked_gather_copy_0
 
  subroutine vector_masked_gather_copy(a, b, mask, n)
    type(vector_t), intent(inout) :: a
    real(kind=rp), dimension(:), intent(in) :: b
    type(mask_t), intent(in) :: mask
    integer, intent(in) :: n
    type(c_ptr) :: mask_d, b_d
 
    if (n .lt. 1 .or. mask%size() .lt. 1) return !Avoid getting null pointers
 
    if (neko_bcknd_device .eq. 1) then
       mask_d = mask%get_d()
       b_d = device_get_ptr(b)
       call device_masked_gather_copy_aligned(a%x_d, b_d, mask_d, n, &
            mask%size())
    else
       call masked_gather_copy(a%x, b, mask%get(), n, mask%size())
    end if
 
  end subroutine vector_masked_gather_copy
 
  subroutine vector_masked_scatter_copy_0(a, b, mask, n, n_mask)
    integer, intent(in) :: n, n_mask
    real(kind=rp), dimension(n), intent(inout) :: a
    type(vector_t), intent(in) :: b
    integer, dimension(0:n_mask) :: mask
    type(c_ptr) :: mask_d, a_d
 
    if (n .lt. 1 .or. n_mask .lt. 1) return !Avoid getting null pointers
 
    if (neko_bcknd_device .eq. 1) then
       a_d = device_get_ptr(a)
       mask_d = device_get_ptr(mask)
       call device_masked_scatter_copy_0(a_d, b%x_d, mask_d, n, n_mask)
    else
       call masked_scatter_copy_0(a, b%x, mask, n, n_mask)
    end if
 
  end subroutine vector_masked_scatter_copy_0
 
  subroutine vector_masked_scatter_copy(a, b, mask, n)
    real(kind=rp), dimension(:), intent(inout) :: a
    type(vector_t), intent(in) :: b
    type(mask_t), intent(in) :: mask
    integer, intent(in) :: n
    type(c_ptr) :: mask_d, a_d
 
    if (n .lt. 1 .or. mask%size() .lt. 1) return !Avoid getting null pointers
 
    if (neko_bcknd_device .eq. 1) then
       a_d = device_get_ptr(a)
       mask_d = mask%get_d()
       call device_masked_scatter_copy_aligned(a_d, b%x_d, mask_d, n, &
            mask%size())
    else
       call masked_scatter_copy(a, b%x, mask%get(), n, mask%size())
    end if
 
  end subroutine vector_masked_scatter_copy
 
  subroutine vector_cwrap(a, min_value, max_value, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    real(kind=rp), intent(in) :: min_value, max_value
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (a%size() .lt. 1) return ! Avoid getting null pointers
 
    if (neko_bcknd_device .eq. 1) then
       call device_cwrap(a%x_d, min_value, max_value, size)
    else
       call cwrap(a%x, min_value, max_value, size)
    end if
 
  end subroutine vector_cwrap
 
  subroutine vector_sqrt_inplace(a, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: a
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_sqrt_inplace(a%x_d, size)
    else
       call sqrt_inplace(a%x, size)
    end if
 
  end subroutine vector_sqrt_inplace
 
  subroutine vector_power(ap, a, p, n)
    integer, intent(in), optional :: n
    type(vector_t), intent(inout) :: ap
    type(vector_t), intent(in) :: a
    real(kind=rp), intent(in) :: p
    integer :: size
 
    if (present(n)) then
       size = n
    else
       size = a%size()
    end if
 
    if (neko_bcknd_device .eq. 1) then
       call device_power(ap%x_d, a%x_d, p, size)
    else
       call power(ap%x, a%x, p, size)
    end if
 
  end subroutine vector_power
 
 
end module vector_math