Actual source code: petsctsmod.F90

      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