Actual source code: petsckspdefmod.F90

      1:         module petscpcdefdummy
      2:         use petscdmdef
      3:         use petscmatdef
      4: #include <../src/ksp/f90-mod/petscpc.h>
      5:         end module petscpcdefdummy

      7:         module petscpcdef
      8:         use petscpcdefdummy
      9:         interface operator(.ne.)
     10:           function pcnotequal(A,B)
     11:             import tPC
     12:             logical pcnotequal
     13:             type(tPC), intent(in) :: A,B
     14:           end function
     15:         end interface operator (.ne.)
     16:         interface operator(.eq.)
     17:           function pcequals(A,B)
     18:             import tPC
     19:             logical pcequals
     20:             type(tPC), intent(in) :: A,B
     21:           end function
     22:         end interface operator (.eq.)
     23:         end module

     25:         function pcnotequal(A,B)
     26:           use petscpcdefdummy, only: tPC
     27:           logical pcnotequal
     28:           type(tPC), intent(in) :: A,B
     29:           pcnotequal = (A%v .ne. B%v)
     30:         end function

     32:         function pcequals(A,B)
     33:           use petscpcdefdummy, only: tPC
     34:           logical pcequals
     35:           type(tPC), intent(in) :: A,B
     36:           pcequals = (A%v .eq. B%v)
     37:         end function

     39:         module petsckspdefdummy
     40:         use petscpcdef
     41: #include <../src/ksp/f90-mod/petscksp.h>
     42:         end module

     44:         module petsckspdef
     45:         use petsckspdefdummy
     46:         interface operator(.ne.)
     47:           function kspnotequal(A,B)
     48:             import tKSP
     49:             logical kspnotequal
     50:             type(tKSP), intent(in) :: A,B
     51:           end function
     52:         end interface operator (.ne.)
     53:         interface operator(.eq.)
     54:           function kspequals(A,B)
     55:             import tKSP
     56:             logical kspequals
     57:             type(tKSP), intent(in) :: A,B
     58:           end function
     59:         end interface operator (.eq.)
     60:         end module

     62:         function kspnotequal(A,B)
     63:           use petsckspdefdummy, only: tKSP
     64:           logical kspnotequal
     65:           type(tKSP), intent(in) :: A,B
     66:           kspnotequal = (A%v .ne. B%v)
     67:         end function

     69:         function kspequals(A,B)
     70:           use petsckspdefdummy, only: tKSP
     71:           logical kspequals
     72:           type(tKSP), intent(in) :: A,B
     73:           kspequals = (A%v .eq. B%v)
     74:         end function