Actual source code: petscvecmod.F90


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

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

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

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

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

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

 64: #if defined(_WIN32) && defined(PETSC_USE_SHARED_LIBRARIES)
 65: !DEC$ ATTRIBUTES DLLEXPORT::isnotequal
 66: !DEC$ ATTRIBUTES DLLEXPORT::petscsfnotequal
 67: !DEC$ ATTRIBUTES DLLEXPORT::isequals
 68: !DEC$ ATTRIBUTES DLLEXPORT::petscsfequals
 69: #endif

 71:         module  petscaodef
 72:         use petscisdef
 73:         use petscsysdef
 74: #include <../src/vec/f90-mod/petscao.h>
 75:         end module

 77:         module petscvecdefdummy
 78:         use petscisdef
 79:         use petscaodef
 80: #include <../src/vec/f90-mod/petscvec.h>
 81:         end module

 83:         module petscvecdef
 84:         use petscvecdefdummy
 85:         interface operator(.ne.)
 86:           function vecnotequal(A,B)
 87:             import tVec
 88:             logical vecnotequal
 89:             type(tVec), intent(in) :: A,B
 90:           end function
 91:           function vecscatternotequal(A,B)
 92:             import tVecScatter
 93:             logical vecscatternotequal
 94:             type(tVecScatter), intent(in) :: A,B
 95:           end function
 96:         end interface operator (.ne.)
 97:         interface operator(.eq.)
 98:           function vecequals(A,B)
 99:             import tVec
100:             logical vecequals
101:             type(tVec), intent(in) :: A,B
102:           end function
103:           function vecscatterequals(A,B)
104:             import tVecScatter
105:             logical vecscatterequals
106:             type(tVecScatter), intent(in) :: A,B
107:           end function
108:         end interface operator (.eq.)
109:         end module

111:         function vecnotequal(A,B)
112:           use petscvecdefdummy, only: tVec
113:           logical vecnotequal
114:           type(tVec), intent(in) :: A,B
115:           vecnotequal = (A%v .ne. B%v)
116:         end function

118:         function vecequals(A,B)
119:           use petscvecdefdummy, only: tVec
120:           logical vecequals
121:           type(tVec), intent(in) :: A,B
122:           vecequals = (A%v .eq. B%v)
123:         end function

125:         function vecscatternotequal(A,B)
126:           use petscvecdefdummy, only: tVecScatter
127:           logical vecscatternotequal
128:           type(tVecScatter), intent(in) :: A,B
129:           vecscatternotequal = (A%v .ne. B%v)
130:         end function

132:         function vecscatterequals(A,B)
133:           use petscvecdefdummy, only: tVecScatter
134:           logical vecscatterequals
135:           type(tVecScatter), intent(in) :: A,B
136:           vecscatterequals = (A%v .eq. B%v)
137:         end function

139: #if defined(_WIN32) && defined(PETSC_USE_SHARED_LIBRARIES)
140: !DEC$ ATTRIBUTES DLLEXPORT::vecnotequal
141: !DEC$ ATTRIBUTES DLLEXPORT::vecscatternotequal
142: !DEC$ ATTRIBUTES DLLEXPORT::vecequals
143: !DEC$ ATTRIBUTES DLLEXPORT::vecscatterequals
144: #endif

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

155:         module petscao
156:         use petscis
157:         use petscaodef
158:         end module

160:         module petscvec
161:         use petscvecdef
162:         use petscis
163:         use petscao
164: #include <../src/vec/f90-mod/petscvec.h90>
165:         interface
166: #include <../src/vec/f90-mod/ftn-auto-interfaces/petscvec.h90>
167:         end interface
168:         end module

170:       subroutine F90ArraySFNodeCreate(array,n,ptr)
171:       use petscis, only: PetscSFNode
172:       implicit none
173:       PetscInt n,array(2*n)
174:       type(PetscSFNode), pointer :: ptr(:)
175:       PetscInt i
176:       allocate(ptr(n))
177:       do i=1,n
178:         ptr(i)%rank  = array(2*i-1)
179:         ptr(i)%index = array(2*i)
180:       enddo

182:       end subroutine