function_cache Derived Type

type, public :: function_cache

a vector function cache.


Inherits

type~~function_cache~~InheritsGraph type~function_cache function_cache type~fx fx type~function_cache->type~fx c

Inherited by

type~~function_cache~~InheritedByGraph type~function_cache function_cache type~numdiff_type numdiff_type type~numdiff_type->type~function_cache cache

Components

Type Visibility Attributes Name Initial
integer, private :: n = 0

size of x
integer, private :: m = 0

size of f
type(fx), private, dimension(:), allocatable :: c

the cache of f(x)
integer, private :: chunk_size = 100

for resizing vectors in the unique function

Type-Bound Procedures

procedure, public :: initialize => initialize_cache

  • private subroutine initialize_cache(me, isize, n, m, chunk_size)

    Initialize the cache. Must be called first before use.

    Arguments

    Type IntentOptional Attributes Name
    class(function_cache), intent(inout) :: me
    integer, intent(in) :: isize

    the size of the hash table
    integer, intent(in) :: n

    number of independant variables (x)
    integer, intent(in) :: m

    number of functions (f)
    integer, intent(in), optional :: chunk_size

    chunk size to speed up reallocation of arrays. A good value is a guess for the actual number of elements of f that will be saved per value of x [default is 100]

procedure, public :: get => get_from_cache

  • private subroutine get_from_cache(me, x, ifs, i, f, xfound, ffound)

    Check if the x vector is in the cache, if so return f. Note that only some of the elements may be present, so it will return the ones there are there, and indicate which ones were found.

    Arguments

    Type IntentOptional Attributes Name
    class(function_cache), intent(inout) :: me
    real(kind=wp), intent(in), dimension(:) :: x

    independant variable vector
    integer, intent(in), dimension(:) :: ifs

    elements of f needed
    integer, intent(out) :: i

    index in the hash table
    real(kind=wp), intent(out), dimension(:) :: f

    f(x) from the cache (if it was found)
    logical, intent(out) :: xfound

    if x was found in the cache
    logical, intent(out), dimension(size(ifs)) :: ffound

    which ifs were found in the cache

procedure, public :: put => put_in_cache

  • private subroutine put_in_cache(me, i, x, f, ifs)

    Put a value into the cache.

    Arguments

    Type IntentOptional Attributes Name
    class(function_cache), intent(inout) :: me
    integer, intent(in) :: i

    index in the hash table
    real(kind=wp), intent(in), dimension(:) :: x

    independant variable vector (dimension n)
    real(kind=wp), intent(in), dimension(:) :: f

    function vector f(x) (dimension m)
    integer, intent(in), dimension(:) :: ifs

    elements of f to add (should all be >0, <=m)

procedure, public :: destroy => destroy_cache

  • private subroutine destroy_cache(me)

    Destroy a cache.

    Arguments

    Type IntentOptional Attributes Name
    class(function_cache), intent(out) :: me

procedure, public :: print => print_cache

  • private subroutine print_cache(me, iunit)

    Print the contents of the cache. Used for debugging.

    Arguments

    Type IntentOptional Attributes Name
    class(function_cache), intent(inout) :: me
    integer, intent(in) :: iunit

    file unit for writing (assumed to be opened)

Source Code

    type,public :: function_cache
        !! a vector function cache.
        private
        integer :: n = 0 !! size of `x`
        integer :: m = 0 !! size of `f`
        type(fx),dimension(:),allocatable :: c  !! the cache of `f(x)`
        integer :: chunk_size = 100 !! for resizing vectors
                                    !! in the [[unique]] function
    contains
        private
        procedure,public :: initialize => initialize_cache
        procedure,public :: get        => get_from_cache
        procedure,public :: put        => put_in_cache
        procedure,public :: destroy    => destroy_cache
        procedure,public :: print      => print_cache
    end type function_cache