1:         module petsctsdefdummy
  2:         use petscsnesdef
  3: #include <../src/ts/f90-mod/petscts.h>
  4:         end module petsctsdefdummy

  6:         module petsctsdef
  7:         use petsctsdefdummy
  8:         interface operator(.ne.)
  9:           function tsnotequal(A,B)
 10:             import tTS
 11:             logical tsnotequal
 12:             type(tTS), intent(in) :: A,B
 13:           end function
 14:           function tsadaptnotequal(A,B)
 15:             import tTSAdapt
 16:             logical tsadaptnotequal
 17:             type(tTSAdapt), intent(in) :: A,B
 18:           end function
 19:           function tstrajectorynotequal(A,B)
 20:             import tTSTrajectory
 21:             logical tstrajectorynotequal
 22:             type(tTSTrajectory), intent(in) :: A,B
 23:           end function
 24:         end interface operator (.ne.)
 25:         interface operator(.eq.)
 26:           function tsequals(A,B)
 27:             import tTS
 28:             logical tsequals
 29:             type(tTS), intent(in) :: A,B
 30:           end function
 31:           function tsadaptequals(A,B)
 32:             import tTSAdapt
 33:             logical tsadaptequals
 34:             type(tTSAdapt), intent(in) :: A,B
 35:           end function
 36:           function tstrajectoryequals(A,B)
 37:             import tTSTrajectory
 38:             logical tstrajectoryequals
 39:             type(tTSTrajectory), intent(in) :: A,B
 40:           end function
 41:         end interface operator (.eq.)
 42:         end module

 44:         function tsnotequal(A,B)
 45:           use petsctsdefdummy, only: tTS
 46:           logical tsnotequal
 47:           type(tTS), intent(in) :: A,B
 48:           tsnotequal = (A%v .ne. B%v)
 49:         end function

 51:         function tsequals(A,B)
 52:           use petsctsdefdummy, only: tTS
 53:           logical tsequals
 54:           type(tTS), intent(in) :: A,B
 55:           tsequals = (A%v .eq. B%v)
 56:         end function

 58:         function tsadaptnotequal(A,B)
 59:           use petsctsdefdummy, only: tTSAdapt
 60:           logical tsadaptnotequal
 61:           type(tTSAdapt), intent(in) :: A,B
 62:           tsadaptnotequal = (A%v .ne. B%v)
 63:         end function

 65:         function tsadaptequals(A,B)
 66:           use petsctsdefdummy, only: tTSAdapt
 67:           logical tsadaptequals
 68:           type(tTSAdapt), intent(in) :: A,B
 69:           tsadaptequals = (A%v .eq. B%v)
 70:         end function

 72:         function tstrajectorynotequal(A,B)
 73:           use petsctsdefdummy, only: tTSTrajectory
 74:           logical tstrajectorynotequal
 75:           type(tTSTrajectory), intent(in) :: A,B
 76:           tstrajectorynotequal = (A%v .ne. B%v)
 77:         end function

 79:         function tstrajectoryequals(A,B)
 80:           use petsctsdefdummy, only: tTSTrajectory
 81:           logical tstrajectoryequals
 82:           type(tTSTrajectory), intent(in) :: A,B
 83:           tstrajectoryequals = (A%v .eq. B%v)
 84:         end function

 86:         module petscts
 87:         use petsctsdef
 88:         use petscsnes
 89: #include <../src/ts/f90-mod/petscts.h90>
 90:         interface
 91: #include <../src/ts/f90-mod/ftn-auto-interfaces/petscts.h90>
 92: #include <../src/ts/f90-mod/ftn-auto-interfaces/petscsensitivity.h90>
 93:         end interface
 94:         end module