sparsemodule Module Reference

Data Types
type	rowtype
type	sparsematrix

Functions/Subroutines
subroutine	destroy (this)
subroutine	initialize (this, nrow, ncol, rowmaxnnz)
subroutine	initializefixed (this, nrow, ncol, maxnnz)
subroutine	filliaja (this, ia, ja, ierror, sort)
subroutine	addconnection (this, i, j, inodup, iaddop)
subroutine	insert (j, thisrow, inodup, iadded)
subroutine	sort (this, with_csr)
subroutine	sortintarray (nval, iarray)
subroutine	csr_diagsum (ia, flowja)

Function/Subroutine Documentation

addconnection()

subroutine sparsemodule::addconnection	(	class(sparsematrix), intent(inout)	this,
		integer(i4b), intent(in)	i,
		integer(i4b), intent(in)	j,
		integer(i4b), intent(in)	inodup,
		integer(i4b), intent(inout), optional	iaddop
	)

Definition at line 149 of file Sparse.f90.

    !add a connection to the sparsematrix.  if inodup
    !(for no duplicates) is 1, then j is added only
    !if it is unique.
    ! -- dummy
    class(sparsematrix), intent(inout) :: this
    integer(I4B), intent(in) :: i, j, inodup
    integer(I4B), optional, intent(inout) :: iaddop
    ! -- local
    integer(I4B) :: irow_local
    integer(I4B) :: iadded
    ! -- code
    !
    ! -- when distributed system, reduce row numbers to local range
    irow_local = i - this%offset
    !
    call insert(j, this%row(irow_local), inodup, iadded)
    this%nnz = this%nnz + iadded
    if (j < this%offset + 1 .or. j > this%offset + this%nrow) then
      ! count the off-diagonal entries separately
      this%nnz_od = this%nnz_od + iadded
    end if
    if (present(iaddop)) iaddop = iadded
    !
    ! -- return
    return

Here is the call graph for this function:

csr_diagsum()

subroutine sparsemodule::csr_diagsum	(	integer(i4b), dimension(:), contiguous	ia,
		real(dp), dimension(:), contiguous	flowja
	)

Definition at line 280 of file Sparse.f90.

    !Add up the off diagonal terms and put the sum in the
    !diagonal position
    ! -- dummy
    integer(I4B), dimension(:), contiguous :: ia
    real(DP), dimension(:), contiguous :: flowja
    ! -- local
    integer(I4B) :: nodes
    integer(I4B) :: n
    integer(I4B) :: iposdiag
    integer(I4B) :: ipos
    ! -- code
    nodes = size(ia) - 1
    do n = 1, nodes
      iposdiag = ia(n)
      do ipos = ia(n) + 1, ia(n + 1) - 1
        flowja(iposdiag) = flowja(iposdiag) + flowja(ipos)
      end do
    end do
    return

Here is the caller graph for this function:

destroy()

subroutine sparsemodule::destroy

(

class(sparsematrix), intent(inout)

this

)

Definition at line 34 of file Sparse.f90.

    class(sparsematrix), intent(inout) :: this
    deallocate (this%row)

filliaja()

subroutine sparsemodule::filliaja	(	class(sparsematrix), intent(inout)	this,
		integer(i4b), dimension(:), intent(inout)	ia,
		integer(i4b), dimension(:), intent(inout)	ja,
		integer(i4b), intent(inout)	ierror,
		logical, intent(in), optional	sort
	)

Definition at line 90 of file Sparse.f90.

    !allocate and fill the ia and ja arrays using information
    !from the sparsematrix.
    !ierror is returned as:
    !  0 if no error
    !  1 if ia is not the correct size
    !  2 if ja is not the correct size
    !  3 if both ia and ja are not correct size
    ! -- dummy
    class(sparsematrix), intent(inout) :: this
    integer(I4B), dimension(:), intent(inout) :: ia, ja
    integer(I4B), intent(inout) :: ierror
    logical, intent(in), optional :: sort
    ! -- local
    logical :: sortja
    integer(I4B) :: i, j, ipos
    ! -- code
    !
    ! -- process optional dummy variables
    if (present(sort)) then
      sortja = sort
    else
      sortja = .false.
    end if
    !
    ! -- initialize error variable
    ierror = 0
    !
    ! -- check for error conditions
    if (ubound(ia, dim=1) /= this%nrow + 1) then
      ierror = 1
    end if
    if (ubound(ja, dim=1) /= this%nnz) then
      ierror = ierror + 2
    end if
    if (ierror /= 0) then
      return
    end if
    !
    ! -- sort this
    if (sortja) then
      call this%sort()
    end if
    !
    ! -- fill ia and ja
    ipos = 1
    ia(1) = ipos
    do i = 1, this%nrow
      do j = 1, this%row(i)%nnz
        ja(ipos) = this%row(i)%icolarray(j)
        ipos = ipos + 1
      end do
      ia(i + 1) = ipos
    end do
    !
    ! -- return
    return

initialize()

subroutine sparsemodule::initialize	(	class(sparsematrix), intent(inout)	this,
		integer(i4b), intent(in)	nrow,
		integer(i4b), intent(in)	ncol,
		integer(i4b), dimension(nrow), intent(in)	rowmaxnnz
	)

Definition at line 39 of file Sparse.f90.

    !initial the sparse matrix.  This subroutine
    !acts a method for a sparse matrix by initializing
    !the row data.  It presently requires one maximum
    !value for all rows, however, this can be changed
    !to a vector of maximum values with one value for
    !each row.
    ! -- dummy
    class(sparsematrix), intent(inout) :: this
    integer(I4B), intent(in) :: nrow, ncol
    integer(I4B), intent(in), dimension(nrow) :: rowmaxnnz
    ! -- local
    integer(I4B) :: i
    ! -- code
    this%offset = 0
    this%nrow = nrow
    this%ncol = ncol
    this%nnz = 0
    this%nnz_od = 0
    allocate (this%row(nrow))
    do i = 1, nrow
      allocate (this%row(i)%icolarray(rowmaxnnz(i)))
      this%row(i)%icolarray = 0
      this%row(i)%nnz = 0
    end do
    !
    ! -- return
    return

Here is the caller graph for this function:

initializefixed()

subroutine sparsemodule::initializefixed	(	class(sparsematrix), intent(inout)	this,
		integer(i4b), intent(in)	nrow,
		integer(i4b), intent(in)	ncol,
		integer(i4b), intent(in)	maxnnz
	)

Definition at line 70 of file Sparse.f90.

    implicit none
    class(sparsematrix), intent(inout) :: this
    integer(I4B), intent(in) :: nrow, ncol
    integer(I4B), intent(in) :: maxnnz
    ! local
    integer(I4B), dimension(:), allocatable :: rowmaxnnz
    integer(I4B) :: i
 
    allocate (rowmaxnnz(nrow))
 
    do i = 1, nrow
      rowmaxnnz(i) = maxnnz
    end do
 
    call this%initialize(nrow, ncol, rowmaxnnz)
    deallocate (rowmaxnnz)
 

Here is the caller graph for this function:

insert()

subroutine sparsemodule::insert	(	integer(i4b), intent(in)	j,
		type(rowtype), intent(inout)	thisrow,
		integer(i4b), intent(in)	inodup,
		integer(i4b), intent(inout)	iadded
	)

Definition at line 177 of file Sparse.f90.

    !insert j into thisrow (for row i)
    !inodup=1 means do not include duplicate connections
    !iadded is 1 if a new entry was added (meaning that nnz for the row was increased)
    !iadded is 0 if duplicate and not added.  Used to track total number of connections
    ! -- dummy
    integer(I4B), intent(in) :: j, inodup
    type(rowtype), intent(inout) :: thisrow
    integer(I4B), allocatable, dimension(:) :: iwk
    integer(I4B), intent(inout) :: iadded
    ! -- local
    integer(I4B) :: jj, maxnnz
    ! -- code
    iadded = 0
    maxnnz = ubound(thisrow%icolarray, dim=1)
    if (thisrow%icolarray(1) == 0) then
      thisrow%icolarray(1) = j
      thisrow%nnz = thisrow%nnz + 1
      iadded = 1
      return
    end if
    if (thisrow%nnz == maxnnz) then
      ! -- increase size of the row
      allocate (iwk(thisrow%nnz))
      iwk = thisrow%icolarray
      deallocate (thisrow%icolarray)
      ! -- Specify how to increase the size of the icolarray.  Adding 1
      !    will be most memory conservative, but may be a little slower
      !    due to frequent allocate/deallocate.  Another option would be
      !    to double the size: maxnnz=maxnnz*2
      maxnnz = maxnnz + 1
      allocate (thisrow%icolarray(maxnnz))
      thisrow%icolarray(1:thisrow%nnz) = iwk(1:thisrow%nnz)
      thisrow%icolarray(thisrow%nnz + 1:maxnnz) = 0
    end if
    if (inodup == 1) then
      do jj = 1, thisrow%nnz
        if (thisrow%icolarray(jj) == j) then
          return
        end if
      end do
    end if
    !
    ! -- add the connection to end
    thisrow%nnz = thisrow%nnz + 1
    thisrow%icolarray(thisrow%nnz) = j
    iadded = 1
    !
    ! -- return
    return

Here is the caller graph for this function:

sort()

subroutine sparsemodule::sort	(	class(sparsematrix), intent(inout)	this,
		logical(lgp), optional	with_csr
	)

Definition at line 229 of file Sparse.f90.

    !sort the icolarray for each row, but do not include
    !the diagonal position in the sort so that it stays in front
    ! -- dummy
    class(sparsematrix), intent(inout) :: this
    logical(LGP), optional :: with_csr
    ! -- local
    integer(I4B) :: i, nval, start_idx
    ! -- code
    start_idx = 2
    if (present(with_csr)) then
      if (with_csr) then
        ! CSR: don't put diagonal up front
        start_idx = 1
      end if
    end if
 
    do i = 1, this%nrow
      nval = this%row(i)%nnz
      call sortintarray(nval - start_idx + 1, &
                        this%row(i)%icolarray(start_idx:nval))
    end do
    !
    ! -- return
    return

Here is the call graph for this function:

sortintarray()

subroutine sparsemodule::sortintarray	(	integer(i4b), intent(in)	nval,
		integer(i4b), dimension(nval), intent(inout)	iarray
	)

Definition at line 256 of file Sparse.f90.

    !simple subroutine for sorting an array
    !in place.  It is not the fastest sort function
    !but should suffice for relatively short nodelists.
    ! -- dummy
    integer(I4B), intent(in) :: nval
    integer(I4B), intent(inout), dimension(nval) :: iarray
    ! -- local
    integer(I4B) :: i, j, itemp
    ! -- code
    do i = 1, nval - 1
      do j = i + 1, nval
        if (iarray(i) > iarray(j)) then
          itemp = iarray(j)
          iarray(j) = iarray(i)
          iarray(i) = itemp
        end if
      end do
    end do
    !
    ! -- return
    return

Here is the caller graph for this function: