text:
      program dsdrv4
c
c     Program to illustrate the idea of reverse communication
c     in shift and invert mode for a generalized symmetric eigenvalue
c     problem.  The following program uses the two LAPACK subroutines
c     dgttrf.f and dgttrs to factor and solve a tridiagonal system of
c     equations.
c
c     We implement example four of ex-sym.doc in DOCUMENTS directory
c
c\Example-4
c     ... Suppose we want to solve A*x = lambda*M*x in inverse mode,
c         where A and M are obtained from the finite element discretrization
c         of the 1-dimensional discrete Laplacian
c                             d^2u / dx^2
c         on the interval [0,1] with zero Dirichlet boundary condition
c         using piecewise linear elements.
c
c     ... OP = (inv[A - sigma*M])*M  and  B = M.
c
c     ... Use mode 3 of DSAUPD.
c
c\BeginLib
c
c\Routines called:
c     dsaupd  ARPACK reverse communication interface routine.
c     dseupd  ARPACK routine that returns Ritz values and (optionally)
c             Ritz vectors.
c     dgttrf  LAPACK tridiagonal factorization routine.
c     dgttrs  LAPACK tridiagonal solve routine.
c     daxpy   Level 1 BLAS that computes y <- alpha*x+y.
c     dcopy   Level 1 BLAS that copies one vector to another.
c     dscal   Level 1 BLAS that scales a vector by a scalar.
c     dnrm2   Level 1 BLAS that computes the norm of a vector.
c     av      Matrix vector multiplication routine that computes A*x.
c     mv      Matrix vector multiplication routine that computes M*x.
c
c\Author
c     Richard Lehoucq
c     Danny Sorensen
c     Chao Yang
c     Dept. of Computational &
c     Applied Mathematics
c     Rice University
c     Houston, Texas
c
c\SCCS Information: @(#)
c FILE: sdrv4.F   SID: 2.5   DATE OF SID: 10/17/00   RELEASE: 2
c
c\Remarks
c     1. None
c
c\EndLib
c----------------------------------------------------------------------
c
c     %-----------------------------%
c     | Define leading dimensions   |
c     | for all arrays.             |
c     | MAXN:   Maximum dimension   |
c     |         of the A allowed.   |
c     | MAXNEV: Maximum NEV allowed |
c     | MAXNCV: Maximum NCV allowed |
c     %-----------------------------%
c
      integer          maxn, maxnev, maxncv, ldv
      parameter        (maxn=256, maxnev=10, maxncv=25,
     &                 ldv=maxn)
c
c     %--------------%
c     | Local Arrays |
c     %--------------%
c
      Double precision
     &                 v(ldv,maxncv), workl(maxncv*(maxncv+8)),
     &                 workd(3*maxn), d(maxncv,2), resid(maxn),
     &                 ad(maxn), adl(maxn), adu(maxn), adu2(maxn)
      logical          select(maxncv)
      integer          iparam(11), ipntr(11), ipiv(maxn)
c
c     %---------------%
c     | Local Scalars |
c     %---------------%
c
      character        bmat*1, which*2
      integer          ido, n, nev, ncv, lworkl, info, j, ierr,
     &                 nconv, maxitr, ishfts, mode
      logical          rvec
      Double precision
     &                 sigma, r1, r2, tol, h
c
c     %------------%
c     | Parameters |
c     %------------%
c
      Double precision
     &                 zero, one, two, four, six
      parameter        (zero = 0.0D+0, one = 1.0D+0,
     &                  four = 4.0D+0, six = 6.0D+0,
     &                  two = 2.0D+0 )
c
c     %-----------------------------%
c     | BLAS & LAPACK routines used |
c     %-----------------------------%
c
      Double precision
     &                 dnrm2
      external         daxpy, dcopy, dscal, dnrm2, dgttrf, dgttrs
c
c     %--------------------%
c     | Intrinsic function |
c     %--------------------%
c
      intrinsic        abs
c
c     %-----------------------%
c     | Executable statements |
c     %-----------------------%
c
c     %----------------------------------------------------%
c     | The number N is the dimension of the matrix.  A    |
c     | generalized eigenvalue problem is solved (BMAT =   |
c     | 'G'.) NEV is the number of eigenvalues (closest to |
c     | the shift SIGMA) to be approximated.  Since the    |
c     | shift-invert mode is used, WHICH is set to 'LM'.   |
c     | The user can modify NEV, NCV, SIGMA to solve       |
c     | problems of different sizes, and to get different  |
c     | parts of the spectrum. However, The following      |
c     | conditions must be satisfied:                      |
c     |                   N <= MAXN,                       |
c     |                 NEV <= MAXNEV,                     |
c     |             NEV + 1 <= NCV <= MAXNCV               |
c     %----------------------------------------------------%
c
      n = 100
      nev = 4
      ncv = 10
      if ( n .gt. maxn ) then
         print *, ' ERROR with _SDRV4: N is greater than MAXN '
         go to 9000
      else if ( nev .gt. maxnev ) then
         print *, ' ERROR with _SDRV4: NEV is greater than MAXNEV '
         go to 9000
      else if ( ncv .gt. maxncv ) then
         print *, ' ERROR with _SDRV4: NCV is greater than MAXNCV '
         go to 9000
      end if
      bmat = 'G'
      which = 'LM'
      sigma = zero
c
c     %--------------------------------------------------%
c     | The work array WORKL is used in DSAUPD as        |
c     | workspace.  Its dimension LWORKL is set as       |
c     | illustrated below.  The parameter TOL determines |
c     | the stopping criterion.  If TOL<=0, machine      |
c     | precision is used.  The variable IDO is used for |
c     | reverse communication and is initially set to 0. |
c     | Setting INFO=0 indicates that a random vector is |
c     | generated in DSAUPD to start the Arnoldi         |
c     | iteration.                                       |
c     %--------------------------------------------------%
c
      lworkl = ncv*(ncv+8)
      tol = zero
      ido = 0
      info = 0
c
c     %---------------------------------------------------%
c     | This program uses exact shifts with respect to    |
c     | the current Hessenberg matrix (IPARAM(1) = 1).    |
c     | IPARAM(3) specifies the maximum number of Arnoldi |
c     | iterations allowed.  Mode 3 specified in the      |
c     | documentation of DSAUPD is used (IPARAM(7) = 3).  |
c     | All these options may be changed by the user.     |
c     | For details, see the documentation in DSAUPD.     |
c     %---------------------------------------------------%
c
      ishfts = 1
      maxitr = 300
      mode   = 3
c
      iparam(1) = ishfts
      iparam(3) = maxitr
      iparam(7) = mode
c
c     %-------------------------------------------------------%
c     | Call LAPACK routine to factor the tridiagonal matrix  |
c     | (A-SIGMA*M).  The matrix A is the 1-d discrete        |
c     | Laplacian. The matrix M is the associated mass matrix |
c     | arising from using piecewise linear finite elements   |
c     | on the interval [0, 1].                               |
c     %-------------------------------------------------------%
c
      h = one / dble(n+1)
      r1 = (four / six) * h
      r2 = (one / six) * h
      do 20 j=1,n
         ad(j) = two/h - sigma * r1
         adl(j) = -one/h - sigma * r2
 20   continue
      call dcopy (n, adl, 1, adu, 1)
      call dgttrf (n, adl, ad, adu, adu2, ipiv, ierr)
      if (ierr .ne. 0) then
         print *, ' Error with _gttrf in _SDRV4.'
         go to 9000
      end if
c
c     %-------------------------------------------%
c     | M A I N   L O O P (Reverse communication) |
c     %-------------------------------------------%
c
 10   continue
c
c        %---------------------------------------------%
c        | Repeatedly call the routine DSAUPD and take |
c        | actions indicated by parameter IDO until    |
c        | either convergence is indicated or maxitr   |
c        | has been exceeded.                          |
c        %---------------------------------------------%
c
         call dsaupd ( ido, bmat, n, which, nev, tol, resid,
     &                 ncv, v, ldv, iparam, ipntr, workd, workl,
     &                 lworkl, info )
c
         if (ido .eq. -1) then
c
c           %--------------------------------------------%
c           | Perform  y <--- OP*x = inv[A-SIGMA*M]*M*x  |
c           | to force the starting vector into the      |
c           | range of OP.  The user should supply       |
c           | his/her own matrix vector multiplication   |
c           | routine and a linear system solver here.   |
c           | The matrix vector multiplication routine   |
c           | takes workd(ipntr(1)) as the input vector. |
c           | The final result is returned to            |
c           | workd(ipntr(2)).                           |
c           %--------------------------------------------%
c
            call mv (n, workd(ipntr(1)), workd(ipntr(2)))
c
            call dgttrs ('Notranspose', n, 1, adl, ad, adu, adu2, ipiv,
     &                   workd(ipntr(2)), n, ierr)
            if (ierr .ne. 0) then
               print *, ' '
               print *, ' Error with _gttrs in _SDRV4. '
               print *, ' '
               go to 9000
            end if
c
c           %-----------------------------------------%
c           | L O O P   B A C K to call DSAUPD again. |
c           %-----------------------------------------%
c
            go to 10
c
         else if (ido .eq. 1) then
c
c           %-----------------------------------------%
c           | Perform y <-- OP*x = inv[A-sigma*M]*M*x |
c           | M*x has been saved in workd(ipntr(3)).  |
c           | the user only needs the linear system   |
c           | solver here that takes workd(ipntr(3)   |
c           | as input, and returns the result to     |
c           | workd(ipntr(2)).                        |
c           %-----------------------------------------%
c
            call dcopy ( n, workd(ipntr(3)), 1, workd(ipntr(2)), 1)
            call dgttrs ('Notranspose', n, 1, adl, ad, adu, adu2, ipiv,
     &                   workd(ipntr(2)), n, ierr)
            if (ierr .ne. 0) then
               print *, ' '
               print *, ' Error with _gttrs in _SDRV4.'
               print *, ' '
               go to 9000
            end if
c
c           %-----------------------------------------%
c           | L O O P   B A C K to call DSAUPD again. |
c           %-----------------------------------------%
c
            go to 10
c
        else if (ido .eq. 2) then
c
c           %-----------------------------------------%
c           |          Perform  y <--- M*x            |
c           | Need the matrix vector multiplication   |
c           | routine here that takes workd(ipntr(1)) |
c           | as the input and returns the result to  |
c           | workd(ipntr(2)).                        |
c           %-----------------------------------------%
c
            call mv (n, workd(ipntr(1)), workd(ipntr(2)))
c
c           %-----------------------------------------%
c           | L O O P   B A C K to call DSAUPD again. |
c           %-----------------------------------------%
c
            go to 10
c
        end if
c
c     %-----------------------------------------%
c     | Either we have convergence, or there is |
c     | an error.                               |
c     %-----------------------------------------%
c
      if ( info .lt. 0 ) then
c
c        %--------------------------%
c        | Error message, check the |
c        | documentation in DSAUPD. |
c        %--------------------------%
c
         print *, ' '
         print *, ' Error with _saupd, info = ',info
         print *, ' Check the documentation of _saupd '
         print *, ' '
c
      else
c
c        %-------------------------------------------%
c        | No fatal errors occurred.                 |
c        | Post-Process using DSEUPD.                |
c        |                                           |
c        | Computed eigenvalues may be extracted.    |
c        |                                           |
c        | Eigenvectors may also be computed now if  |
c        | desired.  (indicated by rvec = .true.)    |
c        %-------------------------------------------%
c
         rvec = .true.
c
         call dseupd ( rvec, 'All', select, d, v, ldv, sigma,
     &        bmat, n, which, nev, tol, resid, ncv, v, ldv,
     &        iparam, ipntr, workd, workl, lworkl, ierr )
c
c        %----------------------------------------------%
c        | Eigenvalues are returned in the first column |
c        | of the two dimensional array D and the       |
c        | corresponding eigenvectors are returned in   |
c        | the first NEV columns of the two dimensional |
c        | array V if requested.  Otherwise, an         |
c        | orthogonal basis for the invariant subspace  |
c        | corresponding to the eigenvalues in D is     |
c        | returned in V.                               |
c        %----------------------------------------------%
c
         if ( ierr .ne. 0 ) then
c
c           %------------------------------------%
c           | Error condition:                   |
c           | Check the documentation of DSEUPD. |
c           %------------------------------------%
c
            print *, ' '
            print *, ' Error with _seupd, info = ', ierr
            print *, ' Check the documentation of _seupd '
            print *, ' '
c
         else
c
            nconv =  iparam(5)
            do 30 j=1, nconv
c
c              %---------------------------%
c              | Compute the residual norm |
c              |                           |
c              |   ||  A*x - lambda*x ||   |
c              |                           |
c              | for the NCONV accurately  |
c              | computed eigenvalues and  |
c              | eigenvectors.  (iparam(5) |
c              | indicates how many are    |
c              | accurate to the requested |
c              | tolerance)                |
c              %---------------------------%
c
               call av(n, v(1,j), workd)
               call mv(n, v(1,j), workd(n+1))
               call daxpy (n, -d(j,1), workd(n+1), 1, workd, 1)
               d(j,2) =  dnrm2(n, workd, 1)
               d(j,2) = d(j,2) / abs(d(j,1))
c
 30         continue
c
            call dmout(6, nconv, 2, d, maxncv, -6,
     &                'Ritz values and relative residuals')
c
        end if
c
c       %------------------------------------------%
c       | Print additional convergence information |
c       %------------------------------------------%
c
        if ( info .eq. 1) then
           print *, ' '
           print *, ' Maximum number of iterations reached.'
           print *, ' '
        else if ( info .eq. 3) then
           print *, ' '
           print *, ' No shifts could be applied during implicit',
     &              ' Arnoldi update, try increasing NCV.'
           print *, ' '
        end if
c
        print *, ' '
        print *, ' _SDRV4 '
        print *, ' ====== '
        print *, ' '
        print *, ' Size of the matrix is ', n
        print *, ' The number of Ritz values requested is ', nev
        print *, ' The number of Arnoldi vectors generated',
     &               ' (NCV) is ', ncv
        print *, ' What portion of the spectrum: ', which
        print *, ' The number of converged Ritz values is ',
     &             nconv
        print *, ' The number of Implicit Arnoldi update',
     &           ' iterations taken is ', iparam(3)
        print *, ' The number of OP*x is ', iparam(9)
        print *, ' The convergence criterion is ', tol
        print *, ' '
c
      end if
c
c     %---------------------------%
c     | Done with program dsdrv4. |
c     %---------------------------%
c
 9000 continue
c
      end
c
c------------------------------------------------------------------------
c     matrix vector subroutine
c     The matrix used is the 1 dimensional mass matrix
c     on the interval [0,1].
c
      subroutine mv (n, v, w)
      integer         n, j
      Double precision
     &                v(n),w(n), one, four, six, h
      parameter       (one = 1.0D+0, four = 4.0D+0,
     &                 six = 6.0D+0)
c
      w(1) =  four*v(1) + v(2)
      do 100 j = 2,n-1
         w(j) = v(j-1) + four*v(j) + v(j+1)
  100 continue
      j = n
      w(j) = v(j-1) + four*v(j)
c
c     Scale the vector w by h.
c
      h = one / ( six*dble(n+1))
      call dscal(n, h, w, 1)
      return
      end
c------------------------------------------------------------------------
c     matrix vector subroutine
c     where the matrix is the finite element discretization of the
c     1 dimensional discrete Laplacian on [0,1] with zero Dirichlet
c     boundary condition using piecewise linear elements.
c
      subroutine av (n, v, w)
      integer           n, j
      Double precision
     &                  v(n), w(n), two, one, h
      parameter         (one = 1.0D+0, two = 2.0D+0)
c
      w(1) =  two*v(1) - v(2)
      do 100 j = 2,n-1
         w(j) = - v(j-1) + two*v(j) - v(j+1)
  100 continue
      j = n
      w(j) = - v(j-1) + two*v(j)
c
c     Scale the vector w by (1/h)
c
      h = one / dble(n+1)
      call dscal(n, one/h, w, 1)
      return
      end

max_stars_repo_name: JamiePringle/ROMScode-PringleBBLpaper

max_issues_repo_name: JamiePringle/ROMScode-PringleBBLpaper

max_forks_repo_name: JamiePringle/ROMScode-PringleBBLpaper


!
!                Parallel Sparse BLAS  version 3.5
!      (C) Copyright 2006, 2010, 2015, 2017
!        Salvatore Filippone    Cranfield University
!        Alfredo Buttari        CNRS-IRIT, Toulouse
!
!    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 following disclaimer.
!      2. Redistributions in binary form must reproduce the above copyright
!         notice, this list of conditions, and the following disclaimer in the
!         documentation and/or other materials provided with the distribution.
!      3. The name of the PSBLAS group or the names of its contributors may
!         not be used to endorse or promote products derived from this
!         software without specific 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 THE PSBLAS GROUP OR ITS 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.
!
!
!
!
module psb_d_base_mat_mod

  use psb_base_mat_mod
  use psb_d_base_vect_mod

  !> \namespace  psb_base_mod  \class  psb_d_base_sparse_mat
  !! \extends psb_base_mat_mod::psb_base_sparse_mat
  !! The psb_d_base_sparse_mat type, extending psb_base_sparse_mat,
  !! defines a middle level  real(psb_dpk_) sparse matrix object.
  !! This class object itself does not have any additional members
  !! with respect to those of the base class. Most methods cannot be fully
  !! implemented at this level, but we can define the interface for the
  !! computational methods requiring the knowledge of the underlying
  !! field, such as the matrix-vector product; this interface is defined,
  !! but is supposed to be overridden at the leaf level.
  !!
  !! About the method MOLD: this has been defined for those compilers
  !! not yet supporting ALLOCATE( ...,MOLD=...); it's otherwise silly to
  !! duplicate "by hand" what is specified in the language (in this case F2008)
  !!
  type, extends(psb_base_sparse_mat) :: psb_d_base_sparse_mat
  contains
    !
    ! Data management methods: defined here, but (mostly) not implemented.
    !
    procedure, pass(a) :: csput_a       => psb_d_base_csput_a
    procedure, pass(a) :: csput_v       => psb_d_base_csput_v
    generic, public    :: csput         => csput_a,  csput_v
    procedure, pass(a) :: csgetrow      => psb_d_base_csgetrow
    procedure, pass(a) :: csgetblk      => psb_d_base_csgetblk
    procedure, pass(a) :: get_diag      => psb_d_base_get_diag
    generic, public    :: csget         => csgetrow, csgetblk
    procedure, pass(a) :: tril          => psb_d_base_tril
    procedure, pass(a) :: triu          => psb_d_base_triu
    procedure, pass(a) :: csclip        => psb_d_base_csclip
    procedure, pass(a) :: cp_to_coo     => psb_d_base_cp_to_coo
    procedure, pass(a) :: cp_from_coo   => psb_d_base_cp_from_coo
    procedure, pass(a) :: cp_to_fmt     => psb_d_base_cp_to_fmt
    procedure, pass(a) :: cp_from_fmt   => psb_d_base_cp_from_fmt
    procedure, pass(a) :: mv_to_coo     => psb_d_base_mv_to_coo
    procedure, pass(a) :: mv_from_coo   => psb_d_base_mv_from_coo
    procedure, pass(a) :: mv_to_fmt     => psb_d_base_mv_to_fmt
    procedure, pass(a) :: mv_from_fmt   => psb_d_base_mv_from_fmt
    procedure, pass(a) :: mold          => psb_d_base_mold
    procedure, pass(a) :: clone         => psb_d_base_clone
    procedure, pass(a) :: make_nonunit  => psb_d_base_make_nonunit
    procedure, pass(a) :: clean_zeros   => psb_d_base_clean_zeros

    !
    ! Transpose methods: defined here but not implemented.
    !
    procedure, pass(a) :: transp_1mat => psb_d_base_transp_1mat
    procedure, pass(a) :: transp_2mat => psb_d_base_transp_2mat
    procedure, pass(a) :: transc_1mat => psb_d_base_transc_1mat
    procedure, pass(a) :: transc_2mat => psb_d_base_transc_2mat

    !
    ! Computational methods: defined here but not implemented.
    !
    procedure, pass(a) :: vect_mv     => psb_d_base_vect_mv
    procedure, pass(a) :: csmv        => psb_d_base_csmv
    procedure, pass(a) :: csmm        => psb_d_base_csmm
    generic, public    :: spmm        => csmm, csmv, vect_mv
    procedure, pass(a) :: in_vect_sv  => psb_d_base_inner_vect_sv
    procedure, pass(a) :: inner_cssv  => psb_d_base_inner_cssv
    procedure, pass(a) :: inner_cssm  => psb_d_base_inner_cssm
    generic, public    :: inner_spsm  => inner_cssm, inner_cssv, in_vect_sv
    procedure, pass(a) :: vect_cssv   => psb_d_base_vect_cssv
    procedure, pass(a) :: cssv        => psb_d_base_cssv
    procedure, pass(a) :: cssm        => psb_d_base_cssm
    generic, public    :: spsm        => cssm, cssv, vect_cssv
    procedure, pass(a) :: scals       => psb_d_base_scals
    procedure, pass(a) :: scalv       => psb_d_base_scal
    generic, public    :: scal        => scals, scalv
    procedure, pass(a) :: maxval      => psb_d_base_maxval
    procedure, pass(a) :: spnmi       => psb_d_base_csnmi
    procedure, pass(a) :: spnm1       => psb_d_base_csnm1
    procedure, pass(a) :: rowsum      => psb_d_base_rowsum
    procedure, pass(a) :: arwsum      => psb_d_base_arwsum
    procedure, pass(a) :: colsum      => psb_d_base_colsum
    procedure, pass(a) :: aclsum      => psb_d_base_aclsum
  end type psb_d_base_sparse_mat

  private :: d_base_mat_sync, d_base_mat_is_host, d_base_mat_is_dev, &
       & d_base_mat_is_sync, d_base_mat_set_host, d_base_mat_set_dev,&
       & d_base_mat_set_sync

  !> \namespace  psb_base_mod  \class  psb_d_coo_sparse_mat
  !! \extends psb_d_base_mat_mod::psb_d_base_sparse_mat
  !!
  !! psb_d_coo_sparse_mat type and the related methods. This is the
  !! reference type for all the format transitions, copies and mv unless
  !! methods are implemented that allow the direct transition from one
  !! format to another. It is defined here since all other classes must
  !! refer to it per the MEDIATOR design pattern.
  !!
  type, extends(psb_d_base_sparse_mat) :: psb_d_coo_sparse_mat
    !> Number of nonzeros.
    integer(psb_ipk_) :: nnz
    !> Row indices.
    integer(psb_ipk_), allocatable :: ia(:)
    !> Column indices.
    integer(psb_ipk_), allocatable :: ja(:)
    !> Coefficient values.
    real(psb_dpk_), allocatable :: val(:)

    integer, private   :: sort_status=psb_unsorted_

  contains
    !
    ! Data management methods.
    !
    procedure, pass(a) :: get_size     => d_coo_get_size
    procedure, pass(a) :: get_nzeros   => d_coo_get_nzeros
    procedure, nopass  :: get_fmt      => d_coo_get_fmt
    procedure, pass(a) :: sizeof       => d_coo_sizeof
    procedure, pass(a) :: reallocate_nz => psb_d_coo_reallocate_nz
    procedure, pass(a) :: allocate_mnnz => psb_d_coo_allocate_mnnz
    procedure, pass(a) :: cp_to_coo    => psb_d_cp_coo_to_coo
    procedure, pass(a) :: cp_from_coo  => psb_d_cp_coo_from_coo
    procedure, pass(a) :: cp_to_fmt    => psb_d_cp_coo_to_fmt
    procedure, pass(a) :: cp_from_fmt  => psb_d_cp_coo_from_fmt
    procedure, pass(a) :: mv_to_coo    => psb_d_mv_coo_to_coo
    procedure, pass(a) :: mv_from_coo  => psb_d_mv_coo_from_coo
    procedure, pass(a) :: mv_to_fmt    => psb_d_mv_coo_to_fmt
    procedure, pass(a) :: mv_from_fmt  => psb_d_mv_coo_from_fmt
    procedure, pass(a) :: csput_a      => psb_d_coo_csput_a
    procedure, pass(a) :: get_diag     => psb_d_coo_get_diag
    procedure, pass(a) :: csgetrow     => psb_d_coo_csgetrow
    procedure, pass(a) :: csgetptn     => psb_d_coo_csgetptn
    procedure, pass(a) :: reinit       => psb_d_coo_reinit
    procedure, pass(a) :: get_nz_row   => psb_d_coo_get_nz_row
    procedure, pass(a) :: fix          => psb_d_fix_coo
    procedure, pass(a) :: trim         => psb_d_coo_trim
    procedure, pass(a) :: clean_zeros  => psb_d_coo_clean_zeros
    procedure, pass(a) :: print        => psb_d_coo_print
    procedure, pass(a) :: free         => d_coo_free
    procedure, pass(a) :: mold         => psb_d_coo_mold
    procedure, pass(a) :: is_sorted    => d_coo_is_sorted
    procedure, pass(a) :: is_by_rows   => d_coo_is_by_rows
    procedure, pass(a) :: is_by_cols   => d_coo_is_by_cols
    procedure, pass(a) :: set_by_rows  => d_coo_set_by_rows
    procedure, pass(a) :: set_by_cols  => d_coo_set_by_cols
    procedure, pass(a) :: set_sort_status => d_coo_set_sort_status
    procedure, pass(a) :: get_sort_status => d_coo_get_sort_status

    !
    ! This is COO specific
    !
    procedure, pass(a) :: set_nzeros   => d_coo_set_nzeros

    !
    ! Transpose methods. These are the base of all
    ! indirection in transpose, together with conversions
    ! they are sufficient for all cases.
    !
    procedure, pass(a) :: transp_1mat => d_coo_transp_1mat
    procedure, pass(a) :: transc_1mat => d_coo_transc_1mat

    !
    ! Computational methods.
    !
    procedure, pass(a) :: csmm       => psb_d_coo_csmm
    procedure, pass(a) :: csmv       => psb_d_coo_csmv
    procedure, pass(a) :: inner_cssm => psb_d_coo_cssm
    procedure, pass(a) :: inner_cssv => psb_d_coo_cssv
    procedure, pass(a) :: scals      => psb_d_coo_scals
    procedure, pass(a) :: scalv      => psb_d_coo_scal
    procedure, pass(a) :: maxval     => psb_d_coo_maxval
    procedure, pass(a) :: spnmi      => psb_d_coo_csnmi
    procedure, pass(a) :: spnm1      => psb_d_coo_csnm1
    procedure, pass(a) :: rowsum     => psb_d_coo_rowsum
    procedure, pass(a) :: arwsum     => psb_d_coo_arwsum
    procedure, pass(a) :: colsum     => psb_d_coo_colsum
    procedure, pass(a) :: aclsum     => psb_d_coo_aclsum

  end type psb_d_coo_sparse_mat

  private :: d_coo_get_nzeros, d_coo_set_nzeros, &
       & d_coo_get_fmt,  d_coo_free, d_coo_sizeof, &
       & d_coo_transp_1mat, d_coo_transc_1mat

  ! == =================
  !
  ! BASE interfaces
  !
  ! == =================

  !> Function  csput:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Insert coefficients.
  !!
  !!
  !!         Given  a list of NZ triples
  !!           (IA(i),JA(i),VAL(i))
  !!         record a new coefficient in A such that
  !!            A(IA(1:nz),JA(1:nz)) = VAL(1:NZ).
  !!
  !!         The internal components IA,JA,VAL are reallocated as necessary.
  !!         Constraints:
  !!         - If the matrix A is in the BUILD state, then the method will
  !!           only work for COO matrices, all other format will throw an error.
  !!           In this case coefficients are queued inside A for further processing.
  !!         - If the matrix A is in the UPDATE state, then it can be in any format;
  !!           the update operation will perform either
  !!               A(IA(1:nz),JA(1:nz)) = VAL(1:NZ)
  !!           or
  !!               A(IA(1:nz),JA(1:nz)) =  A(IA(1:nz),JA(1:nz))+VAL(1:NZ)
  !!           according to the value of DUPLICATE.
  !!         - Coefficients with (IA(I),JA(I)) outside the ranges specified by
  !!           IMIN:IMAX,JMIN:JMAX will be ignored.
  !!
  !!  \param nz    number of triples in input
  !!  \param ia(:)  the input row indices
  !!  \param ja(:)  the input col indices
  !!  \param val(:)  the input coefficients
  !!  \param imin  minimum row index
  !!  \param imax  maximum row index
  !!  \param jmin  minimum col index
  !!  \param jmax  maximum col index
  !!  \param info  return code
  !!  \param gtl(:) [none] an array to renumber indices   (iren(ia(:)),iren(ja(:))
  !!
  !
  interface
    subroutine psb_d_base_csput_a(nz,ia,ja,val,a,imin,imax,jmin,jmax,info,gtl)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      real(psb_dpk_), intent(in)      :: val(:)
      integer(psb_ipk_), intent(in)             :: nz, ia(:), ja(:), imin,imax,jmin,jmax
      integer(psb_ipk_), intent(out)            :: info
      integer(psb_ipk_), intent(in), optional   :: gtl(:)
    end subroutine psb_d_base_csput_a
  end interface

  interface
    subroutine psb_d_base_csput_v(nz,ia,ja,val,a,imin,imax,jmin,jmax,info,gtl)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_, psb_d_base_vect_type,&
           & psb_i_base_vect_type
      class(psb_d_base_sparse_mat), intent(inout) :: a
      class(psb_d_base_vect_type), intent(inout)  :: val
      class(psb_i_base_vect_type), intent(inout)  :: ia, ja
      integer(psb_ipk_), intent(in)             :: nz, imin, imax,jmin,jmax
      integer(psb_ipk_), intent(out)            :: info
      integer(psb_ipk_), intent(in), optional   :: gtl(:)
    end subroutine psb_d_base_csput_v
  end interface

  !
  !
  !> Function  csgetrow:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Get a (subset of) row(s)
  !!
  !!        getrow is the basic method by which the other (getblk, clip) can
  !!        be implemented.
  !!
  !!        Returns the set
  !!           NZ, IA(1:nz), JA(1:nz), VAL(1:NZ)
  !!         each identifying the position of a nonzero in A
  !!         between row indices IMIN:IMAX;
  !!         IA,JA are reallocated as necessary.
  !!
  !!  \param imin  the minimum row index we are interested in
  !!  \param imax  the minimum row index we are interested in
  !!  \param nz the number of output coefficients
  !!  \param ia(:)  the output row indices
  !!  \param ja(:)  the output col indices
  !!  \param val(:)  the output coefficients
  !!  \param info  return code
  !!  \param jmin [1] minimum col index
  !!  \param jmax [a\%get_ncols()] maximum col index
  !!  \param iren(:) [none] an array to return renumbered indices (iren(ia(:)),iren(ja(:))
  !!  \param rscale [false] map [min(ia(:)):max(ia(:))] onto [1:max(ia(:))-min(ia(:))+1]
  !!  \param cscale [false] map [min(ja(:)):max(ja(:))] onto [1:max(ja(:))-min(ja(:))+1]
  !!          ( iren cannot be specified with rscale/cscale)
  !!  \param append [false] append to ia,ja
  !!  \param nzin [none]  if append, then first new entry should go in entry nzin+1
  !!
  !
  interface
    subroutine psb_d_base_csgetrow(imin,imax,a,nz,ia,ja,val,info,&
         & jmin,jmax,iren,append,nzin,rscale,cscale)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      integer(psb_ipk_), intent(in)                  :: imin,imax
      integer(psb_ipk_), intent(out)                 :: nz
      integer(psb_ipk_), allocatable, intent(inout)  :: ia(:), ja(:)
      real(psb_dpk_), allocatable,  intent(inout)    :: val(:)
      integer(psb_ipk_),intent(out)                  :: info
      logical, intent(in), optional        :: append
      integer(psb_ipk_), intent(in), optional        :: iren(:)
      integer(psb_ipk_), intent(in), optional        :: jmin,jmax, nzin
      logical, intent(in), optional        :: rscale,cscale
    end subroutine psb_d_base_csgetrow
  end interface

  !
  !> Function  csgetblk:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Get a (subset of) row(s)
  !!
  !!        getblk is very similar to getrow, except that the output
  !!        is packaged in a psb_d_coo_sparse_mat object
  !!
  !!  \param imin  the minimum row index we are interested in
  !!  \param imax  the minimum row index we are interested in
  !!  \param b     the output (sub)matrix
  !!  \param info  return code
  !!  \param jmin [1] minimum col index
  !!  \param jmax [a\%get_ncols()] maximum col index
  !!  \param iren(:) [none] an array to return renumbered indices (iren(ia(:)),iren(ja(:))
  !!  \param rscale [false] map [min(ia(:)):max(ia(:))] onto [1:max(ia(:))-min(ia(:))+1]
  !!  \param cscale [false] map [min(ja(:)):max(ja(:))] onto [1:max(ja(:))-min(ja(:))+1]
  !!          ( iren cannot be specified with rscale/cscale)
  !!  \param append [false] append to ia,ja
  !!  \param nzin [none]  if append, then first new entry should go in entry nzin+1
  !!
  !
  interface
    subroutine psb_d_base_csgetblk(imin,imax,a,b,info,&
         & jmin,jmax,iren,append,rscale,cscale)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_d_coo_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(in)                  :: imin,imax
      integer(psb_ipk_),intent(out)                  :: info
      logical, intent(in), optional        :: append
      integer(psb_ipk_), intent(in), optional        :: iren(:)
      integer(psb_ipk_), intent(in), optional        :: jmin,jmax
      logical, intent(in), optional        :: rscale,cscale
    end subroutine psb_d_base_csgetblk
  end interface

  !
  !
  !> Function  csclip:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Get a submatrix.
  !!
  !!        csclip is practically identical to getblk.
  !!        One of them has to go away.....
  !!
  !!  \param b     the output submatrix
  !!  \param info  return code
  !!  \param imin [1] the minimum row index we are interested in
  !!  \param imax [a%get_nrows()] the minimum row index we are interested in
  !!  \param jmin [1] minimum col index
  !!  \param jmax [a\%get_ncols()] maximum col index
  !!  \param iren(:) [none] an array to return renumbered indices (iren(ia(:)),iren(ja(:))
  !!  \param rscale [false] map [min(ia(:)):max(ia(:))] onto [1:max(ia(:))-min(ia(:))+1]
  !!  \param cscale [false] map [min(ja(:)):max(ja(:))] onto [1:max(ja(:))-min(ja(:))+1]
  !!          ( iren cannot be specified with rscale/cscale)
  !!  \param append [false] append to ia,ja
  !!  \param nzin [none]  if append, then first new entry should go in entry nzin+1
  !!
  !
  interface
    subroutine psb_d_base_csclip(a,b,info,&
         & imin,imax,jmin,jmax,rscale,cscale)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_d_coo_sparse_mat), intent(out) :: b
      integer(psb_ipk_),intent(out)            :: info
      integer(psb_ipk_), intent(in), optional  :: imin,imax,jmin,jmax
      logical, intent(in), optional            :: rscale,cscale
    end subroutine psb_d_base_csclip
  end interface
  !
  !> Function  tril:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief  Copy the lower triangle, i.e. all entries
  !!         A(I,J) such that J-I <= DIAG
  !!         default value is DIAG=0, i.e. lower triangle up to
  !!         the main diagonal.
  !!         DIAG=-1 means copy the strictly lower triangle
  !!         DIAG= 1 means copy the lower triangle plus the first diagonal
  !!                 of the upper triangle.
  !!         Moreover, apply a clipping by copying entries A(I,J) only if
  !!         IMIN<=I<=IMAX
  !!         JMIN<=J<=JMAX
  !!
  !!  \param l     the output (sub)matrix
  !!  \param info  return code
  !!  \param diag [0] the last diagonal (J-I) to be considered.
  !!  \param imin [1] the minimum row index we are interested in
  !!  \param imax [a\%get_nrows()] the minimum row index we are interested in
  !!  \param jmin [1] minimum col index
  !!  \param jmax [a\%get_ncols()] maximum col index
  !!  \param iren(:) [none] an array to return renumbered indices (iren(ia(:)),iren(ja(:))
  !!  \param rscale [false] map [min(ia(:)):max(ia(:))] onto [1:max(ia(:))-min(ia(:))+1]
  !!  \param cscale [false] map [min(ja(:)):max(ja(:))] onto [1:max(ja(:))-min(ja(:))+1]
  !!          ( iren cannot be specified with rscale/cscale)
  !!  \param append [false] append to ia,ja
  !!  \param nzin [none]  if append, then first new entry should go in entry nzin+1
  !!  \param u  [none]  copy of the complementary triangle
  !!
  !
  interface
    subroutine psb_d_base_tril(a,l,info,diag,imin,imax,&
         & jmin,jmax,rscale,cscale,u)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_d_coo_sparse_mat), intent(out) :: l
      integer(psb_ipk_),intent(out)              :: info
      integer(psb_ipk_), intent(in), optional    :: diag,imin,imax,jmin,jmax
      logical, intent(in), optional              :: rscale,cscale
      class(psb_d_coo_sparse_mat), optional, intent(out) :: u
    end subroutine psb_d_base_tril
  end interface

  !
  !> Function  triu:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief  Copy the upper triangle, i.e. all entries
  !!         A(I,J) such that DIAG <= J-I
  !!         default value is DIAG=0, i.e. upper triangle from
  !!         the main diagonal up.
  !!         DIAG= 1 means copy the strictly upper triangle
  !!         DIAG=-1 means copy the upper triangle plus the first diagonal
  !!                 of the lower triangle.
  !!         Moreover, apply a clipping by copying entries A(I,J) only if
  !!         IMIN<=I<=IMAX
  !!         JMIN<=J<=JMAX
  !!         Optionally copies the lower triangle at the same time
  !!
  !!  \param u     the output (sub)matrix
  !!  \param info  return code
  !!  \param diag [0] the last diagonal (J-I) to be considered.
  !!  \param imin [1] the minimum row index we are interested in
  !!  \param imax [a\%get_nrows()] the minimum row index we are interested in
  !!  \param jmin [1] minimum col index
  !!  \param jmax [a\%get_ncols()] maximum col index
  !!  \param iren(:) [none] an array to return renumbered indices (iren(ia(:)),iren(ja(:))
  !!  \param rscale [false] map [min(ia(:)):max(ia(:))] onto [1:max(ia(:))-min(ia(:))+1]
  !!  \param cscale [false] map [min(ja(:)):max(ja(:))] onto [1:max(ja(:))-min(ja(:))+1]
  !!          ( iren cannot be specified with rscale/cscale)
  !!  \param append [false] append to ia,ja
  !!  \param nzin [none]  if append, then first new entry should go in entry nzin+1
  !!  \param l  [none]  copy of the complementary triangle
  !!
  !
  interface
    subroutine psb_d_base_triu(a,u,info,diag,imin,imax,&
         & jmin,jmax,rscale,cscale,l)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_d_coo_sparse_mat), intent(out) :: u
      integer(psb_ipk_),intent(out)              :: info
      integer(psb_ipk_), intent(in), optional    :: diag,imin,imax,jmin,jmax
      logical, intent(in), optional              :: rscale,cscale
      class(psb_d_coo_sparse_mat), optional, intent(out) :: l
    end subroutine psb_d_base_triu
  end interface

  !
  !> Function  get_diag:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Extract the diagonal of A.
  !!
  !!   D(i) = A(i:i), i=1:min(nrows,ncols)
  !!
  !! \param d(:)  The output diagonal
  !! \param info  return code.
  !
  interface
    subroutine psb_d_base_get_diag(a,d,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)     :: d(:)
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_get_diag
  end interface

  !
  !> Function  mold:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Allocate a class(psb_d_base_sparse_mat) with the
  !!     same dynamic type as the input.
  !!     This is equivalent to allocate(  mold=  ) and is provided
  !!     for those compilers not yet supporting mold.
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_mold(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_long_int_k_
      class(psb_d_base_sparse_mat), intent(in)                 :: a
      class(psb_d_base_sparse_mat), intent(inout), allocatable :: b
      integer(psb_ipk_), intent(out)                           :: info
    end subroutine psb_d_base_mold
  end interface

  !
  !
  !> Function  clone:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Allocate and clone  a class(psb_d_base_sparse_mat) with the
  !!     same dynamic type as the input.
  !!     This is equivalent to allocate( source=  ) except that
  !!     it should guarantee a deep copy wherever needed.
  !!     Should also be equivalent to calling mold and then copy,
  !!     but it can also be implemented by default using cp_to_fmt.
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_clone(a,b, info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_long_int_k_
      implicit none
      class(psb_d_base_sparse_mat), intent(inout)              :: a
      class(psb_d_base_sparse_mat), allocatable, intent(inout) :: b
      integer(psb_ipk_), intent(out)                           :: info
    end subroutine psb_d_base_clone
  end interface

  !
  !
  !> Function  make_nonunit:
  !! \memberof  psb_d_base_make_nonunit
  !! \brief Given a matrix for which is_unit() is true, explicitly
  !!     store the unit diagonal and set is_unit() to false.
  !!     This is needed e.g. when scaling
  !
  interface
    subroutine psb_d_base_make_nonunit(a)
      import :: psb_d_base_sparse_mat
      implicit none
      class(psb_d_base_sparse_mat), intent(inout) :: a
    end subroutine psb_d_base_make_nonunit
  end interface

  !
  !> Function  cp_to_coo:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Copy and convert to psb_d_coo_sparse_mat
  !!        Invoked from the source object.
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_cp_to_coo(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_d_coo_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_cp_to_coo
  end interface

  !
  !> Function  cp_from_coo:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Copy and convert from psb_d_coo_sparse_mat
  !!        Invoked from the target object.
  !!   \param b The input variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_cp_from_coo(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      class(psb_d_coo_sparse_mat), intent(in)     :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_cp_from_coo
  end interface

  !
  !> Function  cp_to_fmt:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Copy and convert to a class(psb_d_base_sparse_mat)
  !!        Invoked from the source object. Can be implemented by
  !!        simply invoking a%cp_to_coo(tmp) and then b%cp_from_coo(tmp).
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_cp_to_fmt(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_d_base_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_cp_to_fmt
  end interface

  !
  !> Function  cp_from_fmt:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Copy and convert from a class(psb_d_base_sparse_mat)
  !!        Invoked from the target object. Can be implemented by
  !!        simply invoking b%cp_to_coo(tmp) and then a%cp_from_coo(tmp).
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_cp_from_fmt(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      class(psb_d_base_sparse_mat), intent(in) :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_cp_from_fmt
  end interface

  !
  !> Function  mv_to_coo:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Convert to psb_d_coo_sparse_mat, freeing the source.
  !!        Invoked from the source object.
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_mv_to_coo(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      class(psb_d_coo_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_mv_to_coo
  end interface

  !
  !> Function  mv_from_coo:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Convert from psb_d_coo_sparse_mat, freeing the source.
  !!        Invoked from the target object.
  !!   \param b The input variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_mv_from_coo(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      class(psb_d_coo_sparse_mat), intent(inout)  :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_mv_from_coo
  end interface

  !
  !> Function  mv_to_fmt:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Convert to a class(psb_d_base_sparse_mat), freeing the source.
  !!        Invoked from the source object. Can be implemented by
  !!        simply invoking a%mv_to_coo(tmp) and then b%mv_from_coo(tmp).
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_mv_to_fmt(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      class(psb_d_base_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_mv_to_fmt
  end interface

  !
  !> Function  mv_from_fmt:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Convert from a class(psb_d_base_sparse_mat), freeing the source.
  !!        Invoked from the target object. Can be implemented by
  !!        simply invoking b%mv_to_coo(tmp) and then a%mv_from_coo(tmp).
  !!   \param b The output variable
  !!   \param info return code
  !
  interface
    subroutine psb_d_base_mv_from_fmt(a,b,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      class(psb_d_base_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_mv_from_fmt
  end interface
  !
  !>
  !! \memberof  psb_d_base_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_clean_zeros
  !
  interface
    subroutine  psb_d_base_clean_zeros(a, info)
      import :: psb_ipk_, psb_d_base_sparse_mat
      class(psb_d_base_sparse_mat), intent(inout) :: a
      integer(psb_ipk_), intent(out)              :: info
    end subroutine psb_d_base_clean_zeros
  end interface

  !
  !> Function  transp:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Transpose. Can always be implemented by staging through a COO
  !!        temporary for which transpose is very easy.
  !!        Copyout version
  !!   \param b The output variable
  !
   interface
    subroutine psb_d_base_transp_2mat(a,b)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_base_sparse_mat), intent(out)    :: b
    end subroutine psb_d_base_transp_2mat
  end interface

  !
  !> Function  transc:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Conjugate Transpose. Can always be implemented by staging through a COO
  !!        temporary for which transpose is very easy.
  !!        Copyout version.
  !!   \param b The output variable
  !
  interface
    subroutine psb_d_base_transc_2mat(a,b)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      class(psb_base_sparse_mat), intent(out)    :: b
    end subroutine psb_d_base_transc_2mat
  end interface

  !
  !> Function  transp:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Transpose. Can always be implemented by staging through a COO
  !!        temporary for which transpose is very easy.
  !!        In-place version.
  !
  interface
    subroutine psb_d_base_transp_1mat(a)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
    end subroutine psb_d_base_transp_1mat
  end interface

  !
  !> Function  transc:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Conjugate Transpose. Can always be implemented by staging through a COO
  !!        temporary for which transpose is very easy.
  !!        In-place version.
  !
  interface
    subroutine psb_d_base_transc_1mat(a)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
    end subroutine psb_d_base_transc_1mat
  end interface

  !
  !> Function  csmm:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Product by a dense rank 2 array.
  !!
  !!        Compute
  !!           Y = alpha*op(A)*X + beta*Y
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x(:,:) the input dense X
  !! \param beta   Scaling factor for y
  !! \param y(:,:) the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !!
  !
  interface
    subroutine psb_d_base_csmm(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)    :: alpha, beta, x(:,:)
      real(psb_dpk_), intent(inout) :: y(:,:)
      integer(psb_ipk_), intent(out)            :: info
      character, optional, intent(in) :: trans
    end subroutine psb_d_base_csmm
  end interface

  !> Function  csmv:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Product by a dense rank 1 array.
  !!
  !!        Compute
  !!           Y = alpha*op(A)*X + beta*Y
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x(:)   the input dense X
  !! \param beta   Scaling factor for y
  !! \param y(:)   the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !!
  !
  interface
    subroutine psb_d_base_csmv(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)    :: alpha, beta, x(:)
      real(psb_dpk_), intent(inout) :: y(:)
      integer(psb_ipk_), intent(out)            :: info
      character, optional, intent(in) :: trans
    end subroutine psb_d_base_csmv
  end interface

  !> Function  vect_mv:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Product by an encapsulated array type(psb_d_vect_type)
  !!
  !!        Compute
  !!           Y = alpha*op(A)*X + beta*Y
  !!        Usually the unwrapping of the encapsulated vector is done
  !!        here, so that all the derived classes need only the
  !!        versions with the standard arrays.
  !!        Must be overridden explicitly in case of non standard memory
  !!        management; an example would be external memory allocation
  !!        in attached processors such as GPUs.
  !!
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x      the input X
  !! \param beta   Scaling factor for y
  !! \param y      the input/output  Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !!
  !
  interface
    subroutine psb_d_base_vect_mv(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_, psb_d_base_vect_type
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)       :: alpha, beta
      class(psb_d_base_vect_type), intent(inout) :: x
      class(psb_d_base_vect_type), intent(inout) :: y
      integer(psb_ipk_), intent(out)             :: info
      character, optional, intent(in)  :: trans
    end subroutine psb_d_base_vect_mv
  end interface

  !
  !> Function  cssm:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Triangular system solve by a dense rank 2 array.
  !!
  !!        Compute
  !!           Y = alpha*op(A^-1)*X + beta*Y
  !!
  !!        Internal workhorse called by cssm.
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x(:,:) the input dense X
  !! \param beta   Scaling factor for y
  !! \param y(:,:) the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !!
  !
  interface
    subroutine psb_d_base_inner_cssm(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)    :: alpha, beta, x(:,:)
      real(psb_dpk_), intent(inout) :: y(:,:)
      integer(psb_ipk_), intent(out)            :: info
      character, optional, intent(in) :: trans
    end subroutine psb_d_base_inner_cssm
  end interface

  !
  !> Function  cssv:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Triangular system solve by a dense rank 1 array.
  !!
  !!        Compute
  !!           Y = alpha*op(A^-1)*X + beta*Y
  !!
  !!        Internal workhorse called by cssv.
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x(:)   the input dense X
  !! \param beta   Scaling factor for y
  !! \param y(:)   the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !! \param scale  [N] Apply a scaling on Right (R) i.e. ADX
  !!               or on the Left (L)  i.e.  DAx
  !! \param D(:)   [none] Diagonal for scaling.
  !!
  !
  interface
    subroutine psb_d_base_inner_cssv(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)    :: alpha, beta, x(:)
      real(psb_dpk_), intent(inout) :: y(:)
      integer(psb_ipk_), intent(out)            :: info
      character, optional, intent(in) :: trans
    end subroutine psb_d_base_inner_cssv
  end interface

  !
  !> Function  inner_vect_cssv:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Triangular system solve by
  !!        an encapsulated array type(psb_d_vect_type)
  !!
  !!        Compute
  !!           Y = alpha*op(A^-1)*X + beta*Y
  !!
  !!        Internal workhorse called by vect_cssv.
  !!        Must be overridden explicitly in case of non standard memory
  !!        management; an example would be external memory allocation
  !!        in attached processors such as GPUs.
  !!
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x      the input dense X
  !! \param beta   Scaling factor for y
  !! \param y     the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !
  interface
    subroutine psb_d_base_inner_vect_sv(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_,  psb_d_base_vect_type
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)       :: alpha, beta
      class(psb_d_base_vect_type), intent(inout) :: x, y
      integer(psb_ipk_), intent(out)             :: info
      character, optional, intent(in)  :: trans
    end subroutine psb_d_base_inner_vect_sv
  end interface

  !
  !> Function  cssm:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Triangular system solve by a dense rank 2 array.
  !!
  !!        Compute
  !!           Y = alpha*op(A^-1)*X + beta*Y
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x(:,:) the input dense X
  !! \param beta   Scaling factor for y
  !! \param y(:,:) the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !! \param scale  [N] Apply a scaling on Right (R) i.e. ADX
  !!               or on the Left (L)  i.e.  DAx
  !! \param D(:)   [none] Diagonal for scaling.
  !!
  !
  interface
    subroutine psb_d_base_cssm(alpha,a,x,beta,y,info,trans,scale,d)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)    :: alpha, beta, x(:,:)
      real(psb_dpk_), intent(inout) :: y(:,:)
      integer(psb_ipk_), intent(out)            :: info
      character, optional, intent(in) :: trans, scale
      real(psb_dpk_), intent(in), optional :: d(:)
    end subroutine psb_d_base_cssm
  end interface

  !
  !> Function  cssv:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Triangular system solve by a dense rank 1 array.
  !!
  !!        Compute
  !!           Y = alpha*op(A^-1)*X + beta*Y
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x(:)   the input dense X
  !! \param beta   Scaling factor for y
  !! \param y(:)   the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !! \param scale  [N] Apply a scaling on Right (R) i.e. ADX
  !!               or on the Left (L)  i.e.  DAx
  !! \param D(:)   [none] Diagonal for scaling.
  !!
  !
  interface
    subroutine psb_d_base_cssv(alpha,a,x,beta,y,info,trans,scale,d)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)    :: alpha, beta, x(:)
      real(psb_dpk_), intent(inout) :: y(:)
      integer(psb_ipk_), intent(out)            :: info
      character, optional, intent(in) :: trans, scale
      real(psb_dpk_), intent(in), optional :: d(:)
    end subroutine psb_d_base_cssv
  end interface

  !
  !> Function  vect_cssv:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Triangular system solve by
  !!        an encapsulated array type(psb_d_vect_type)
  !!
  !!        Compute
  !!           Y = alpha*op(A^-1)*X + beta*Y
  !!
  !! \param alpha  Scaling factor for Ax
  !! \param A      the input sparse matrix
  !! \param x      the input dense X
  !! \param beta   Scaling factor for y
  !! \param y     the input/output dense Y
  !! \param info   return code
  !! \param trans  [N] Whether to use A (N), its transpose (T)
  !!               or its conjugate transpose (C)
  !! \param scale  [N] Apply a scaling on Right (R) i.e. ADX
  !!               or on the Left (L)  i.e.  DAx
  !! \param D      [none] Diagonal for scaling.
  !!
  !
  interface
    subroutine psb_d_base_vect_cssv(alpha,a,x,beta,y,info,trans,scale,d)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_,psb_d_base_vect_type
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)       :: alpha, beta
      class(psb_d_base_vect_type), intent(inout) :: x,y
      integer(psb_ipk_), intent(out)             :: info
      character, optional, intent(in)  :: trans, scale
      class(psb_d_base_vect_type), optional, intent(inout)   :: d
    end subroutine psb_d_base_vect_cssv
  end interface

  !
  !> Function  base_scals:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Scale a matrix by a single scalar value
  !!
  !! \param d      Scaling factor
  !! \param info   return code
  !
  interface
    subroutine psb_d_base_scals(d,a,info)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      real(psb_dpk_), intent(in)      :: d
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_base_scals
  end interface

  !
  !> Function  base_scal:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Scale a matrix by a vector
  !!
  !! \param d(:)   Scaling vector
  !! \param info   return code
  !! \param side   [L] Scale on the Left (rows) or on the Right (columns)
  !
  interface
    subroutine psb_d_base_scal(d,a,info,side)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(inout) :: a
      real(psb_dpk_), intent(in)      :: d(:)
      integer(psb_ipk_), intent(out)            :: info
      character, intent(in), optional :: side
    end subroutine psb_d_base_scal
  end interface

  !
  !> Function  base_maxval:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Maximum absolute value of all coefficients;
  !!
  !
  interface
    function psb_d_base_maxval(a) result(res)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_)         :: res
    end function psb_d_base_maxval
  end interface

  !
  !
  !> Function  base_csnmi:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Operator infinity norm
  !!
  !
  interface
    function psb_d_base_csnmi(a) result(res)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_)         :: res
    end function psb_d_base_csnmi
  end interface

  !
  !
  !> Function  base_csnmi:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Operator 1-norm
  !!
  !
  interface
    function psb_d_base_csnm1(a) result(res)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_)         :: res
    end function psb_d_base_csnm1
  end interface

  !
  !
  !> Function  base_rowsum:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Sum along the rows
  !! \param d(:) The output row sums
  !!
  !
  interface
    subroutine psb_d_base_rowsum(d,a)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_base_rowsum
  end interface

  !
  !> Function  base_arwsum:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Absolute value sum along the rows
  !! \param d(:) The output row sums
  !!
  interface
    subroutine psb_d_base_arwsum(d,a)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_base_arwsum
  end interface

  !
  !
  !> Function  base_colsum:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Sum along the columns
  !! \param d(:) The output col sums
  !!
  !
  interface
    subroutine psb_d_base_colsum(d,a)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_base_colsum
  end interface

  !
  !> Function  base_aclsum:
  !! \memberof  psb_d_base_sparse_mat
  !! \brief Absolute value sum along the columns
  !! \param d(:) The output col sums
  !!
  interface
    subroutine psb_d_base_aclsum(d,a)
      import :: psb_ipk_, psb_d_base_sparse_mat, psb_dpk_
      class(psb_d_base_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_base_aclsum
  end interface

  ! == ===============
  !
  ! COO interfaces
  !
  ! == ===============

  !
  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_base_mat_mod::psb_base_reallocate_nz
  !
  interface
    subroutine  psb_d_coo_reallocate_nz(nz,a)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      integer(psb_ipk_), intent(in) :: nz
      class(psb_d_coo_sparse_mat), intent(inout) :: a
    end subroutine psb_d_coo_reallocate_nz
  end interface

  !
  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_base_mat_mod::psb_base_reinit
  !
  interface
    subroutine psb_d_coo_reinit(a,clear)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      logical, intent(in), optional :: clear
    end subroutine psb_d_coo_reinit
  end interface
  !
  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_base_mat_mod::psb_base_trim
  !
  interface
    subroutine  psb_d_coo_trim(a)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
    end subroutine psb_d_coo_trim
  end interface
  !
  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_clean_zeros
  !
  interface
    subroutine  psb_d_coo_clean_zeros(a,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      integer(psb_ipk_), intent(out)             :: info
    end subroutine psb_d_coo_clean_zeros
  end interface

  !
  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_base_mat_mod::psb_base_allocate_mnnz
  !
  interface
    subroutine  psb_d_coo_allocate_mnnz(m,n,a,nz)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      integer(psb_ipk_), intent(in) :: m,n
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      integer(psb_ipk_), intent(in), optional :: nz
    end subroutine psb_d_coo_allocate_mnnz
  end interface

  !> \memberof psb_d_coo_sparse_mat
  !| \see psb_base_mat_mod::psb_base_mold
  interface
    subroutine psb_d_coo_mold(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_d_base_sparse_mat, psb_long_int_k_
      class(psb_d_coo_sparse_mat), intent(in)                  :: a
      class(psb_d_base_sparse_mat), intent(inout), allocatable :: b
      integer(psb_ipk_), intent(out)                           :: info
    end subroutine psb_d_coo_mold
  end interface

  !
  !> Function print.
  !! \memberof  psb_d_coo_sparse_mat
  !! \brief Print the matrix to file in MatrixMarket format
  !!
  !! \param iout  The unit to write to
  !! \param iv    [none] Renumbering for both rows and columns
  !! \param head  [none] Descriptive header for the file
  !! \param ivr   [none] Row renumbering
  !! \param ivc   [none] Col renumbering
  !!
  !
  interface
    subroutine psb_d_coo_print(iout,a,iv,head,ivr,ivc)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      integer(psb_ipk_), intent(in)               :: iout
      class(psb_d_coo_sparse_mat), intent(in) :: a
      integer(psb_ipk_), intent(in), optional     :: iv(:)
      character(len=*), optional        :: head
      integer(psb_ipk_), intent(in), optional     :: ivr(:), ivc(:)
    end subroutine psb_d_coo_print
  end interface

  !
  !> Function get_nz_row.
  !! \memberof  psb_d_coo_sparse_mat
  !! \brief How many nonzeros in a row?
  !!
  !! \param idx  The row to search.
  !!
  !
  interface
    function  psb_d_coo_get_nz_row(idx,a) result(res)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(in) :: a
      integer(psb_ipk_), intent(in)                  :: idx
      integer(psb_ipk_) :: res
    end function psb_d_coo_get_nz_row
  end interface

  !
  !> Funtion: fix_coo_inner
  !! \brief Make sure the entries are sorted and duplicates are handled.
  !!   Used internally by fix_coo
  !! \param nzin  Number of entries on input to be  handled
  !! \param dupl  What to do with duplicated entries.
  !! \param ia(:) Row indices
  !! \param ja(:) Col indices
  !! \param val(:) Coefficients
  !! \param nzout  Number of entries after sorting/duplicate handling
  !! \param info   return code
  !! \param idir [psb_row_major_] Sort in row major order or col major order
  !!
  !
  interface
    subroutine psb_d_fix_coo_inner(nr,nc,nzin,dupl,ia,ja,val,nzout,info,idir)
      import :: psb_ipk_, psb_dpk_
      integer(psb_ipk_), intent(in)           :: nr,nc,nzin,dupl
      integer(psb_ipk_), intent(inout)        :: ia(:), ja(:)
      real(psb_dpk_), intent(inout) :: val(:)
      integer(psb_ipk_), intent(out)          :: nzout, info
      integer(psb_ipk_), intent(in), optional :: idir
    end subroutine psb_d_fix_coo_inner
  end interface

  !
  !> Function fix_coo
  !! \memberof  psb_d_coo_sparse_mat
  !! \brief Make sure the entries are sorted and duplicates are handled.
  !! \param info   return code
  !! \param idir [psb_row_major_] Sort in row major order or col major order
  !!
  !
  interface
    subroutine psb_d_fix_coo(a,info,idir)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      integer(psb_ipk_), intent(out)                :: info
      integer(psb_ipk_), intent(in), optional :: idir
    end subroutine psb_d_fix_coo
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_cp_to_coo
  interface
    subroutine psb_d_cp_coo_to_coo(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(in) :: a
      class(psb_d_coo_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_cp_coo_to_coo
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_cp_from_coo
  interface
    subroutine psb_d_cp_coo_from_coo(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      class(psb_d_coo_sparse_mat), intent(in)    :: b
      integer(psb_ipk_), intent(out)               :: info
    end subroutine psb_d_cp_coo_from_coo
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_cp_from_coo
  !!
  interface
    subroutine psb_d_cp_coo_to_fmt(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_d_base_sparse_mat
      class(psb_d_coo_sparse_mat), intent(in)   :: a
      class(psb_d_base_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)                       :: info
    end subroutine psb_d_cp_coo_to_fmt
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_cp_from_fmt
  !!
   interface
    subroutine psb_d_cp_coo_from_fmt(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_d_base_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      class(psb_d_base_sparse_mat), intent(in)   :: b
      integer(psb_ipk_), intent(out)                        :: info
    end subroutine psb_d_cp_coo_from_fmt
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_mv_to_coo
  interface
    subroutine psb_d_mv_coo_to_coo(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      class(psb_d_coo_sparse_mat), intent(inout)   :: b
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_mv_coo_to_coo
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_mv_from_coo
  interface
    subroutine psb_d_mv_coo_from_coo(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      class(psb_d_coo_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)                        :: info
    end subroutine psb_d_mv_coo_from_coo
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_mv_to_fmt
  interface
    subroutine psb_d_mv_coo_to_fmt(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_d_base_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      class(psb_d_base_sparse_mat), intent(inout)  :: b
      integer(psb_ipk_), intent(out)                        :: info
    end subroutine psb_d_mv_coo_to_fmt
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_mv_from_fmt
  interface
    subroutine psb_d_mv_coo_from_fmt(a,b,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_d_base_sparse_mat
      class(psb_d_coo_sparse_mat), intent(inout)  :: a
      class(psb_d_base_sparse_mat), intent(inout) :: b
      integer(psb_ipk_), intent(out)                         :: info
    end subroutine psb_d_mv_coo_from_fmt
  end interface

  interface
    subroutine psb_d_coo_cp_from(a,b)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      type(psb_d_coo_sparse_mat), intent(in)   :: b
    end subroutine psb_d_coo_cp_from
  end interface

  interface
    subroutine psb_d_coo_mv_from(a,b)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(inout)  :: a
      type(psb_d_coo_sparse_mat), intent(inout) :: b
    end subroutine psb_d_coo_mv_from
  end interface

  !> Function csput
  !! \memberof  psb_d_coo_sparse_mat
  !! \brief  Add coefficients into the matrix.
  !!
  !! \param nz  Number of entries to be added
  !! \param ia(:) Row indices
  !! \param ja(:) Col indices
  !! \param val(:) Values
  !! \param imin  Minimum row index to accept
  !! \param imax  Maximum row index to accept
  !! \param jmin  Minimum col index to accept
  !! \param jmax  Maximum col index to accept
  !! \param info return code
  !! \param gtl [none] Renumbering for rows/columns
  !!
  !
  interface
    subroutine psb_d_coo_csput_a(nz,ia,ja,val,a,imin,imax,jmin,jmax,info,gtl)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      real(psb_dpk_), intent(in)      :: val(:)
      integer(psb_ipk_), intent(in)             :: nz,ia(:), ja(:),&
           &  imin,imax,jmin,jmax
      integer(psb_ipk_), intent(out)            :: info
      integer(psb_ipk_), intent(in), optional   :: gtl(:)
    end subroutine psb_d_coo_csput_a
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_base_mat_mod::psb_base_csgetptn
  interface
    subroutine psb_d_coo_csgetptn(imin,imax,a,nz,ia,ja,info,&
         & jmin,jmax,iren,append,nzin,rscale,cscale)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      integer(psb_ipk_), intent(in)                  :: imin,imax
      integer(psb_ipk_), intent(out)                 :: nz
      integer(psb_ipk_), allocatable, intent(inout)  :: ia(:), ja(:)
      integer(psb_ipk_),intent(out)                  :: info
      logical, intent(in), optional        :: append
      integer(psb_ipk_), intent(in), optional        :: iren(:)
      integer(psb_ipk_), intent(in), optional        :: jmin,jmax, nzin
      logical, intent(in), optional        :: rscale,cscale
    end subroutine psb_d_coo_csgetptn
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_csgetrow
  interface
    subroutine psb_d_coo_csgetrow(imin,imax,a,nz,ia,ja,val,info,&
         & jmin,jmax,iren,append,nzin,rscale,cscale)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      integer(psb_ipk_), intent(in)                  :: imin,imax
      integer(psb_ipk_), intent(out)                 :: nz
      integer(psb_ipk_), allocatable, intent(inout)  :: ia(:), ja(:)
      real(psb_dpk_), allocatable,  intent(inout)    :: val(:)
      integer(psb_ipk_),intent(out)                  :: info
      logical, intent(in), optional        :: append
      integer(psb_ipk_), intent(in), optional        :: iren(:)
      integer(psb_ipk_), intent(in), optional        :: jmin,jmax, nzin
      logical, intent(in), optional        :: rscale,cscale
    end subroutine psb_d_coo_csgetrow
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_cssv
  interface
    subroutine psb_d_coo_cssv(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)          :: alpha, beta, x(:)
      real(psb_dpk_), intent(inout)       :: y(:)
      integer(psb_ipk_), intent(out)                :: info
      character, optional, intent(in)     :: trans
    end subroutine psb_d_coo_cssv
  end interface
  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_cssm
  interface
    subroutine psb_d_coo_cssm(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)          :: alpha, beta, x(:,:)
      real(psb_dpk_), intent(inout)       :: y(:,:)
      integer(psb_ipk_), intent(out)                :: info
      character, optional, intent(in)     :: trans
    end subroutine psb_d_coo_cssm
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_csmv
  interface
    subroutine psb_d_coo_csmv(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)          :: alpha, beta, x(:)
      real(psb_dpk_), intent(inout)       :: y(:)
      integer(psb_ipk_), intent(out)                :: info
      character, optional, intent(in)     :: trans
    end subroutine psb_d_coo_csmv
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_csmm
  interface
    subroutine psb_d_coo_csmm(alpha,a,x,beta,y,info,trans)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(in)          :: alpha, beta, x(:,:)
      real(psb_dpk_), intent(inout)       :: y(:,:)
      integer(psb_ipk_), intent(out)                :: info
      character, optional, intent(in)     :: trans
    end subroutine psb_d_coo_csmm
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_maxval
  interface
    function psb_d_coo_maxval(a) result(res)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_)         :: res
    end function psb_d_coo_maxval
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_csnmi
  interface
    function psb_d_coo_csnmi(a) result(res)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_)         :: res
    end function psb_d_coo_csnmi
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_csnm1
  interface
    function psb_d_coo_csnm1(a) result(res)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_)         :: res
    end function psb_d_coo_csnm1
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_rowsum
  interface
    subroutine psb_d_coo_rowsum(d,a)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_coo_rowsum
  end interface
  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_arwsum
  interface
    subroutine psb_d_coo_arwsum(d,a)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_coo_arwsum
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_colsum
  interface
    subroutine psb_d_coo_colsum(d,a)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_coo_colsum
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_aclsum
  interface
    subroutine psb_d_coo_aclsum(d,a)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)              :: d(:)
    end subroutine psb_d_coo_aclsum
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_get_diag
  interface
    subroutine psb_d_coo_get_diag(a,d,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(in) :: a
      real(psb_dpk_), intent(out)     :: d(:)
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_coo_get_diag
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_scal
  interface
    subroutine psb_d_coo_scal(d,a,info,side)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      real(psb_dpk_), intent(in)      :: d(:)
      integer(psb_ipk_), intent(out)            :: info
      character, intent(in), optional :: side
    end subroutine psb_d_coo_scal
  end interface

  !>
  !! \memberof  psb_d_coo_sparse_mat
  !! \see psb_d_base_mat_mod::psb_d_base_scals
  interface
    subroutine psb_d_coo_scals(d,a,info)
      import :: psb_ipk_, psb_d_coo_sparse_mat, psb_dpk_
      class(psb_d_coo_sparse_mat), intent(inout) :: a
      real(psb_dpk_), intent(in)      :: d
      integer(psb_ipk_), intent(out)            :: info
    end subroutine psb_d_coo_scals
  end interface

contains

  ! == ==================================
  !
  !
  !
  ! Getters
  !
  !
  !
  !
  !
  ! == ==================================

  function d_coo_sizeof(a) result(res)
    implicit none
    class(psb_d_coo_sparse_mat), intent(in) :: a
    integer(psb_long_int_k_) :: res
    res = 8 + 1
    res = res + psb_sizeof_dp  * psb_size(a%val)
    res = res + psb_sizeof_int * psb_size(a%ia)
    res = res + psb_sizeof_int * psb_size(a%ja)

  end function d_coo_sizeof

  function d_coo_get_fmt() result(res)
    implicit none
    character(len=5) :: res
    res = 'COO'
  end function d_coo_get_fmt

  function d_coo_get_size(a) result(res)
    implicit none
    class(psb_d_coo_sparse_mat), intent(in) :: a
    integer(psb_ipk_) :: res
    res = -1

    if (allocated(a%ia)) res = size(a%ia)
    if (allocated(a%ja)) then
      if (res >= 0) then
        res = min(res,size(a%ja))
      else
        res = size(a%ja)
      end if
    end if
    if (allocated(a%val)) then
      if (res >= 0) then
        res = min(res,size(a%val))
      else
        res = size(a%val)
      end if
    end if
  end function d_coo_get_size

  function d_coo_get_nzeros(a) result(res)
    implicit none
    class(psb_d_coo_sparse_mat), intent(in) :: a
    integer(psb_ipk_) :: res
    res  = a%nnz
  end function d_coo_get_nzeros

  function d_coo_is_by_rows(a) result(res)
    implicit none
    class(psb_d_coo_sparse_mat), intent(in) :: a
    logical :: res
    res  = (a%sort_status == psb_row_major_)
  end function d_coo_is_by_rows

  function d_coo_is_by_cols(a) result(res)
    implicit none
    class(psb_d_coo_sparse_mat), intent(in) :: a
    logical :: res
    res  = (a%sort_status == psb_col_major_)
  end function d_coo_is_by_cols

  function d_coo_is_sorted(a) result(res)
    implicit none
    class(psb_d_coo_sparse_mat), intent(in) :: a
    logical :: res
    res  = (a%sort_status == psb_row_major_) &
         & .or.(a%sort_status == psb_col_major_)
  end function d_coo_is_sorted

  ! == ==================================
  !
  !
  !
  ! Setters
  !
  !
  !
  !
  !
  !
  ! == ==================================

  subroutine  d_coo_set_nzeros(nz,a)
    implicit none
    integer(psb_ipk_), intent(in) :: nz
    class(psb_d_coo_sparse_mat), intent(inout) :: a

    a%nnz = nz

  end subroutine d_coo_set_nzeros

  function d_coo_get_sort_status(a) result(res)
    implicit none
    integer(psb_ipk_)   :: res
    class(psb_d_coo_sparse_mat), intent(in) :: a

    res = a%sort_status
  end function d_coo_get_sort_status

  subroutine  d_coo_set_sort_status(ist,a)
    implicit none
    integer(psb_ipk_), intent(in)   :: ist
    class(psb_d_coo_sparse_mat), intent(inout) :: a

    a%sort_status = ist
    call a%set_sorted((a%sort_status == psb_row_major_) &
         & .or.(a%sort_status == psb_col_major_))
  end subroutine d_coo_set_sort_status

  subroutine  d_coo_set_by_rows(a)
    implicit none
    class(psb_d_coo_sparse_mat), intent(inout) :: a

    a%sort_status = psb_row_major_
    call a%set_sorted()
  end subroutine d_coo_set_by_rows

  subroutine  d_coo_set_by_cols(a)
    implicit none
    class(psb_d_coo_sparse_mat), intent(inout) :: a

    a%sort_status = psb_col_major_
    call a%set_sorted()
  end subroutine d_coo_set_by_cols

  ! == ==================================
  !
  !
  !
  ! Data management
  !
  !
  !
  !
  !
  ! == ==================================

  subroutine  d_coo_free(a)
    implicit none

    class(psb_d_coo_sparse_mat), intent(inout) :: a

    if (allocated(a%ia)) deallocate(a%ia)
    if (allocated(a%ja)) deallocate(a%ja)
    if (allocated(a%val)) deallocate(a%val)
    call a%set_null()
    call a%set_nrows(izero)
    call a%set_ncols(izero)
    call a%set_nzeros(izero)
    call a%set_sort_status(psb_unsorted_)

    return

  end subroutine d_coo_free

  ! == ==================================
  !
  !
  !
  ! Computational routines
  !
  !
  !
  !
  !
  !
  ! == ==================================
  subroutine d_coo_transp_1mat(a)
    implicit none

    class(psb_d_coo_sparse_mat), intent(inout) :: a

    integer(psb_ipk_), allocatable :: itemp(:)
    integer(psb_ipk_) :: info

    call a%psb_d_base_sparse_mat%psb_base_sparse_mat%transp()
    call move_alloc(a%ia,itemp)
    call move_alloc(a%ja,a%ia)
    call move_alloc(itemp,a%ja)

    call a%set_sorted(.false.)
    call a%set_sort_status(psb_unsorted_)

    return

  end subroutine d_coo_transp_1mat

  subroutine d_coo_transc_1mat(a)
    implicit none

    class(psb_d_coo_sparse_mat), intent(inout) :: a

    call a%transp()
    ! This will morph into conjg() for C and Z
    ! and into a no-op for S and D, so a conditional
    ! on a constant ought to take it out completely.
    if (psb_d_is_complex_) a%val(:) = (a%val(:))

  end subroutine d_coo_transc_1mat

end module psb_d_base_mat_mod


text:
I often mention Davis Wiki offhand and people say whats that?. Invariably, I give a three paragraph answer that causes most people to stop paying attention. How would you sum up Davis Wiki in one or two sentences? Should any of these be the Mission Statement Davis Wiki Mission Statement?

Davis Wiki is a cooperative website that the entire community builds, edits, and changes. Users/AlphaDog

Its a collaboratively edited website devoted to all things Davis. Users/KenBloom

Daviswiki will change your life Users/KrisFricke

Davis Wiki is like Thanksgiving with the family: everybody brings something to the table and fights incessantly. Users/AlphaDog
  Haha, I like this one!

The only Davis multiplayer live journal. Users/ChristopherMckenzie

DavisWiki has been known to cause WikiAddikies. Users/SummerSong

The Hitchhikers Guide to Davis Users/KenjiYamada
  That one is awesome!! Users/AllisonEriksen

Davis authoritative bathroom wall. (Anyone can add to it, its fun to read, sometimes scandalous, and it can change the world.)  Users/JaimeRaba

Davis Wiki is an open group of volunteers working on a free and publically owned encyclopedia about Davis.  You should join and add an entry for (insert their favorite local topic). Users/JabberWokky
  Even though this is two sentences, I like it the best.

I wish I was as cool as the Davis Wiki Users/KarlMogel

The 411 on the 530. Users/RobRoy
  Doesnt 530 go all the way east to nevada and north to oregon? next up, http://chicowiki.org ChicoWiki.org  Users/ArlenAbraham arlen
   Im not Rob, but yes, it does.
     Yeah Yeah Yeah, but Davis is the only part that matters. Users/RobRoy

Davis Wiki is why everybody else knows more about Davis than you do. Users/CarlMcCabe
   Ha! I really like this one.  After my first main month of randomized page browsing, I knew a ton of random stuff that made people constantly ask why and how I even knew it.  Id end up pointing this or that out around town and mentioning some random factoid.  That would be also be a great slogan for flyers, Carl.

  Davis Wiki  The easiest way to find makeout spots before the Freshman arrive.
  Davis Wiki  The Virtual Deathstar
  Davis Wiki  More addictive than crack.
  Davis Wiki  For those too lazy to decide where theyll eat today.
  Davis Wiki  Thousands of useful pages, and a few created by Michael Giardina.
  Davis Wiki  Its like Robot Media, without... media... or robots.
  Davis Wiki  Davis largest movement for the local acquisition of Dim Sum.
  Davis Wiki  Comparing the advertised pizza with a digital camera realityshot since 2004.
Users/MichaelGiardina

A Davis resource that doesnt suck. Users/SteveDavison (from a Davis wiki flyer)

Have you heard of / know what Wikipedia is? There is one for Davis.   It has an obvious flaw I know, if they dont know what wikipedia is it takes more than a sentence to sum that up... Users/StevenDaubert
  Daviswiki also has a different set of social norms from Wikipedia  Users/JasonAller
 The next sentences his how wikipedia is npov and we encourage opinio  Users/StevenDaubert

Flying cars, thrift stores, and the discovery of the new world; all in one big, ongoing argument.

20080817 01:48:10 nbsp Absolutely amazing. Why was this not mentioned at my orientation?! Users/ThanhVu

One view that is reasonable to derive but most regular wiki editors would probably disagree with is that the purpose of the DavisWiki is to inform new Davis students of aspects of the Davis community (http://daviswiki.org/Davis_Aikikai?actiondiff&version237&version136 here)

20090509 13:42:02 nbsp The Davis wiki is an invaluable resource for newcomers to Davis as well as ongoing residents; best of all, it provides the opportunity to contribute to that resource yourself. Users/CovertProfessor

20100531 08:02:35 nbsp Davis Wiki is not just a resource  or a social networking site.  Were not an online community.  This is our community. Users/CurlyGirl26

Remembrances, anecdotes and stories from the actual people who lived and live here and participate in the events that encompass the community of Davis.  As a primary source, we are what Wikipedia cites.

20100605 22:56:02 nbsp The Davis Wiki is a collection of clear, consistent and informative cows sauteed by collaborating editors who all think in exactly the same cheese. Users/IDoNotExist

20100605 23:31:42 nbsp The Davis Wiki is a story written by its own characters. Users/IDoNotExist

20100606 08:26:11 nbsp A small breath of anarchy amongst the fascists. Users/JimStewart

Its like reading a video game strategy guide lists of NPCs, places and events of importance, etc. :P  Quoted from a poster on http://boards.straightdope.com/sdmb/showthread.php?t568579 The Straight Dope

20100706 22:03:11 nbsp Daviswiki makes me feel like a real woman.  Users/MasonMurray

20100808 17:22:52 nbsp Its like if wikipedia, craigslist, the yellow pages, and consumer reports were to have a drunken orgy and give birth to the most useful thing in the world, or at least the most useful thing in Davis. Users/PhilipNeustrom
 Solid Daubert
 Fabulous!   Users/CovertProfessor

20100819 17:26:10 nbsp Re: communicating with other editors: http://daviswiki.org/Users/PhilipNeustrom?actiondiff&version21636&version11635 Email that you can rewrite after hitting send and realizing it could be interpreted poorly. Users/JabberWokky

The one place in Davis that is always open 24 hours a day, including holidays.  Users/WesP

20100928 23:58:14 nbsp Its sort of like Minecraft  simple structure, seemingly limitless possibility, highly addicting, a fair share of griefers, and cows.  Users/jefftolentino
  On second thought, maybe Minecraft is more like Daviswiki... Users/jefftolentino

ext: f

max_stars_repo_name: voflo/Search

max_issues_repo_name: voflo/Search

max_forks_repo_name: voflo/Search


text:
Modern sarcastic commentators say that flowers are the sign of a guilty man.  Prove them wrong and pick up some today for your significant other for no reason other than celebrating their companionship.

Florists

   Strelitzia Flower Co

Flowers can also be found at:

  Nugget
  Safeway
  Save Mart
  Trader Joes


text:
Youth for Hope is a studentfounded and studentrun peace organization in Davis, California. It was founded by Davis High School sophomore Julia Cortopassi after she watched a screening of http://imdb.com/title/tt0446345 The Ground Truth on 20061204 at the Varsity Theatre. She is assisted by her friends Sophia Cortopassi, Elisa Espinoza, and Jessica Weidenfeld. They stress YFH is not an antiwar organization, but a peace organization.

Their first public event was filling Central Park with Youth for Hope Peace Vigil 10,000 luminaries on New Years Eve.

On 20061231, 67PM they held a new years eve candlelighting event in which 10,000 votive candles and a little compost were placed in white paper bags and set covering the inner area of Central Park.  At 6PM there was a brief prayer, several spoke about the war, interspersed with performances by the Davis High School choir.

Julia said http://www.icasualties.org/oif Three thousand of the candles were to remember the http://www.icasualties.org/oif/US_NAMES.aspx U.S casualties of the Iraq war, the other http://www.iraqbodycount.org seven thousand, times ten, represent the Iraqis who were killed.

Volunteers started setting the candles up at 8AM, they started lighting them at 4PM, and the vigil started at 6PM. All of the planning was accomplished in only a couple weeks time. Total power output of 10,000 burning candles: approx. 400kW. Reportedly, Julias parents paid the $3000 tab for the candles and bags.

Other supporters included Freedom From War (now Teach Peace), Code Pink, Capitol Area Progressives, Progressive Democrats of America, and the Davis Community Church.


text:
Describe Users/lindakimsey here.

20120720 11:48:16 nbsp Hi Linda, Welcome to the Wiki/Business Owner welcome to the Wiki!  I reverted your deletion of the comment on the Simmons Real Estate page.  Please read over the welcome link I just provided  itll explain why, as well as providing some good advice for responding constructively to negative reviews.

By contrast, the removal of those three comments from Kings & Queens Apartments just seems to make sense.  The page reflects that it was formerly a senior living location.  Thanks for updating the page! Users/TomGarberson


text:
program compute_statistics
    use, intrinsic :: iso_fortran_env, only : dp => REAL64
    use :: statistics, only : stats_type, init_stats, add_stats, &
                              mean_stats, stddev_stats
    implicit none
    real(kind=dp), parameter :: x_min = 1.0, x_max = 20.0, x_incr = 0.5
    type(stats_type) :: stats
    real(kind=dp) :: x

    call init_stats(stats)
    x = x_min
    do while (x <= x_max)
        call add_stats(stats, x)
        x = x + x_incr
    end do
    print *, 'mean =', mean_stats(stats)
    print *, 'stddev =', stddev_stats(stats)
    print *, 'n =', stats%n

end program compute_statistics

max_stars_repo_name: gjbex/FortranForProgrammers

max_issues_repo_name: gjbex/FortranForProgrammers

max_forks_repo_name: gjbex/FortranForProgrammers


text:
! RUN: %python %S/test_folding.py %s %flang_fc1
! Check array sizes with varying extents, including extents where the upper
! bound is less than the lower bound
module m
 contains
  subroutine s1(a,b)
    real nada1(-2:-1)    ! size =  2
    real nada2(-1:-1)    ! size =  1
    real nada3( 0:-1)    ! size =  0
    real nada4( 1:-1)    ! size =  0
    real nada5( 2:-1)    ! size =  0
    real nada6( 3:-1)    ! size =  0
    real nada7( 5, 3:-1) ! size =  0
    real nada8( -1)      ! size =  0

    integer, parameter :: size1 = size(nada1)
    integer, parameter :: size2 = size(nada2)
    integer, parameter :: size3 = size(nada3)
    integer, parameter :: size4 = size(nada4)
    integer, parameter :: size5 = size(nada5)
    integer, parameter :: size6 = size(nada6)
    integer, parameter :: size7 = size(nada7)
    integer, parameter :: size8 = size(nada8)

    logical, parameter :: test_size_1 = size1 == 2
    logical, parameter :: test_size_2 = size2 == 1
    logical, parameter :: test_size_3 = size3 == 0
    logical, parameter :: test_size_4 = size4 == 0
    logical, parameter :: test_size_5 = size5 == 0
    logical, parameter :: test_size_6 = size6 == 0
    logical, parameter :: test_size_7 = size7 == 0
    logical, parameter :: test_size_8 = size8 == 0
  end subroutine
end module

max_stars_repo_name: mkinsner/llvm

max_issues_repo_name: mkinsner/llvm

max_forks_repo_name: mkinsner/llvm