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:       implicit none
157: #include <../src/sys/f90-mod/petscsys.h>
158: #include <../src/vec/f90-mod/petscis.h>
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