Actual source code: petscvecmod.F
petsc-3.10.5 2019-03-28
Report Typos and Errors

      2:         module petscisdefdummy
      3:         use petscsysdef
      4: #include <../src/vec/f90-mod/petscis.h>
      5:         end module

      7:         module petscisdef
      8:         use petscisdefdummy
      9:         interface operator(.ne.)
     10:           function isnotequal(A,B)
     11:             use petscisdefdummy
     12:             logical isnotequal
     13:             type(tIS), intent(in) :: A,B
     14:           end function
     15:           function petscsfnotequal(A,B)
     16:             use petscisdefdummy
     17:             logical petscsfnotequal
     18:             type(tPetscSF), intent(in) :: A,B
     19:           end function
     20:         end interface operator (.ne.)
     21:         interface operator(.eq.)
     22:           function isequals(A,B)
     23:             use petscisdefdummy
     24:             logical isequals
     25:             type(tIS), intent(in) :: A,B
     26:           end function
     27:           function petscsfequals(A,B)
     28:             use petscisdefdummy
     29:             logical petscsfequals
     30:             type(tPetscSF), intent(in) :: A,B
     31:           end function
     32:         end interface operator (.eq.)
     33:         end module

     35:         function isnotequal(A,B)
     36:           use petscisdefdummy
     37:           logical isnotequal
     38:           type(tIS), intent(in) :: A,B
     39:           isnotequal = (A%v .ne. B%v)
     40:         end function

     42:         function isequals(A,B)
     43:           use petscisdefdummy
     44:           logical isequals
     45:           type(tIS), intent(in) :: A,B
     46:           isequals = (A%v .eq. B%v)
     47:         end function

     49:         function petscsfnotequal(A,B)
     50:           use petscisdefdummy
     51:           logical petscsfnotequal
     52:           type(tPetscSF), intent(in) :: A,B
     53:           petscsfnotequal = (A%v .ne. B%v)
     54:         end function

     56:         function petscsfequals(A,B)
     57:           use petscisdefdummy
     58:           logical petscsfequals
     59:           type(tPetscSF), intent(in) :: A,B
     60:           petscsfequals = (A%v .eq. B%v)
     61:         end function

     63:         module  petscaodef
     64:         use petscisdef
     65:         use petscsysdef
     66: #include <../src/vec/f90-mod/petscao.h>
     67:         end module

     69:         module petscvecdefdummy
     70:         use petscisdef
     71:         use petscaodef
     72: #include <../src/vec/f90-mod/petscvec.h>
     73:         end module

     75:         module petscvecdef
     76:         use petscvecdefdummy
     77:         interface operator(.ne.)
     78:           function vecnotequal(A,B)
     79:             use petscvecdefdummy
     80:             logical vecnotequal
     81:             type(tVec), intent(in) :: A,B
     82:           end function
     83:           function vecscatternotequal(A,B)
     84:             use petscvecdefdummy
     85:             logical vecscatternotequal
     86:             type(tVecScatter), intent(in) :: A,B
     87:           end function
     88:         end interface operator (.ne.)
     89:         interface operator(.eq.)
     90:           function vecequals(A,B)
     91:             use petscvecdefdummy
     92:             logical vecequals
     93:             type(tVec), intent(in) :: A,B
     94:           end function
     95:           function vecscatterequals(A,B)
     96:             use petscvecdefdummy
     97:             logical vecscatterequals
     98:             type(tVecScatter), intent(in) :: A,B
     99:           end function
    100:         end interface operator (.eq.)
    101:         end module

    103:         function vecnotequal(A,B)
    104:           use petscvecdefdummy
    105:           logical vecnotequal
    106:           type(tVec), intent(in) :: A,B
    107:           vecnotequal = (A%v .ne. B%v)
    108:         end function

    110:         function vecequals(A,B)
    111:           use petscvecdefdummy
    112:           logical vecequals
    113:           type(tVec), intent(in) :: A,B
    114:           vecequals = (A%v .eq. B%v)
    115:         end function

    117:         function vecscatternotequal(A,B)
    118:           use petscvecdefdummy
    119:           logical vecscatternotequal
    120:           type(tVecScatter), intent(in) :: A,B
    121:           vecscatternotequal = (A%v .ne. B%v)
    122:         end function

    124:         function vecscatterequals(A,B)
    125:           use petscvecdefdummy
    126:           logical vecscatterequals
    127:           type(tVecScatter), intent(in) :: A,B
    128:           vecscatterequals = (A%v .eq. B%v)
    129:         end function

    131:         module petscis
    132:         use petscisdef
    133:         use petscsys
    134: #include <../src/vec/f90-mod/petscis.h90>
    135:         interface
    136: #include <../src/vec/f90-mod/ftn-auto-interfaces/petscis.h90>
    137:         end interface
    138:         end module

    140:         module petscao
    141:         use petscis
    142:         use petscaodef
    143:         end module

    145:         module petscvec
    146:         use petscvecdef
    147:         use petscis
    148:         use petscao
    149: #include <../src/vec/f90-mod/petscvec.h90>
    150:         interface
    151: #include <../src/vec/f90-mod/ftn-auto-interfaces/petscvec.h90>
    152:         end interface
    153:         end module

    155:       subroutine F90ArraySFNodeCreate(array,n,ptr)
    156:       use petscsys
    157:       use petscis
    158:       implicit none
    159:       PetscInt n,array(2*n)
    160:       type(PetscSFNode), pointer :: ptr(:)
    161:       PetscInt i
    162:       allocate(ptr(n))
    163:       do i=1,n
    164:         ptr(i)%rank  = array(2*i-1)
    165:         ptr(i)%index = array(2*i)
    166:       enddo

    168:       end subroutine