vector.f90

Go to the documentation of this file.

!##############################################################################
!     ________  _____  ______________ 
!    / ____/  |/  / / / /_  __/  _/ / 
!   / /_  / /|_/ / / / / / /  / // /  
!  / __/ / /  / / /_/ / / / _/ // /___
! /_/   /_/  /_/\____/ /_/ /___/_____/                                     
!
! Copyright 2020 Bharat Mahajan
!
! Licensed under the Apache License, Version 2.0 (the "License");
! you may not use this file except in compliance with the License.
! You may obtain a copy of the License at
!
!    http://www.apache.org/licenses/LICENSE-2.0
!
! Unless required by applicable law or agreed to in writing, software
! distributed under the License is distributed on an "AS IS" BASIS,
! WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
! See the License for the specific language governing permissions and
! limitations under the License.
!
!
!##############################################################################
 
    
module vectors
 
    use fmutilbase
    
    implicit none
    
    private
 
    integer, parameter :: default_bktcap = 3
 
    integer, parameter :: default_newbktsallocated = 2
 
    type, abstract, public :: vecelem
    contains
        procedure(assign_vecelem), deferred :: assignvecelem
        generic, public :: assignment(=) => assignvecelem
    end type vecelem
 
    abstract interface
 
    subroutine assign_vecelem(lhs, rhs)
        import :: vecelem
        implicit none
        class(vecelem), intent(out) :: lhs
        class(vecelem), intent(in) :: rhs
    end subroutine assign_vecelem    
    end interface
 
    type, public, extends(vecelem) :: invalidvecelem
        private
        logical :: invalid = .true.
    contains
        private
        procedure, public :: assignvecelem => assign_invalidelem
    end type invalidvecelem
 
    type, private :: bkt
        private        
        class(vecelem), dimension(:), allocatable :: bktdata
        logical, dimension(:), allocatable :: slotfree
    contains
        private
        procedure :: bktinit
        procedure :: bktclear
        procedure :: add_bktelem
        procedure :: del_bktelem
        procedure :: bktelem
        procedure :: bktsliceptr
        procedure :: is_bktempty
        procedure :: bktsz
    end type bkt
 
    type :: bktptr
        type(bkt), pointer :: pbkt => null()
    end type bktptr
 
    type, public :: vector
        
        private
        
        integer, public :: status = 0
 
        logical :: storageallocated = .false.
 
        integer :: newbktstoallocate = default_newbktsallocated
        
        integer :: bktcap = default_bktcap
 
        integer :: usedbkts = 0
 
        integer :: allocatedbkts = 0
 
        class(vecelem), allocatable :: moldelem
 
        type(bktptr), dimension(:), allocatable :: vecdata
 
    contains
    
        private
 
        procedure :: assignvector
 
        generic, public :: assignment(=) => assignvector
        
        ! Internal procedures
        procedure :: create_newbkts
        procedure :: index2bkt
 
        procedure, public :: init => initialize
 
        procedure, public :: size => vec_size
 
        procedure, public :: capacity
 
        procedure, public :: nusedbkts
 
        procedure, public :: reserve
 
        procedure, public :: shrinktofit
 
        procedure, public :: pushback => push_back
 
        procedure, public :: popback => pop_back        
        
        procedure, public :: elemat => elem_at
 
        procedure, public :: front => elem_front
 
        procedure, public :: back => elem_back
 
        procedure, public :: slice => vec_slice
 
        procedure, public :: bktslice => bkt_slice
 
        procedure, public :: insert => elem_insert
 
        procedure, public :: erase => elem_erase
 
        procedure, public :: clear
 
        final :: destroy
 
    end type vector
 
 
    
    contains
 
 
    
    subroutine initialize(me, NewBktsToAllocate, BktCap, MoldElem)
        implicit none
        
        class(vector), intent(inout) :: me
        integer, intent(in), optional :: NewBktsToAllocate
        integer, intent(in), optional :: BktCap
        class(vecelem), intent(in), optional :: MoldElem
 
        ! Set the number of new buckets to allocate when last bucket is full
        if (present(newbktstoallocate)) me%NewBktsToAllocate = newbktstoallocate
 
        ! If Vector is already initialized, we are done
        if (me%StorageAllocated) return
 
        if (present(bktcap)) me%BktCap = bktcap
 
        ! if mold_elem is provided, then allocate initial buckets
        if (present(moldelem)) then
            allocate(me%MoldElem, source=moldelem)
            call me%create_newbkts(me%NewBktsToAllocate)
        end if
        ! If successful, start using the first bucket
        if (me%status == 0) then
            me%StorageAllocated = .true.
            me%UsedBkts = 1
        end if
    end subroutine initialize
 
 
 
 
    pure function vec_size(me)
        implicit none
        class(vector), intent(in) :: me
        integer :: vec_size
 
        vec_size = 0
        ! if not allocated size is 0
        if ((.NOT. me%StorageAllocated) .OR. me%UsedBkts == 0) return
 
        ! N-1 full bkts and Nth partial filled bkts
        vec_size = (me%UsedBkts-1)*me%BktCap &
                    + me%VecData(me%UsedBkts)%pBkt%bktsz()
    end function vec_size
 
 
 
    pure function capacity(me)
        implicit none
        class(vector), intent(in) :: me
        integer :: capacity
 
        capacity = me%AllocatedBkts*me%BktCap
    end function capacity
 
 
    pure function nusedbkts(me)
        implicit none
        class(vector), intent(in) :: me
        integer :: nusedbkts
 
        nusedbkts = me%UsedBkts
    end function nusedbkts
 
 
 
 
    subroutine reserve(me, n)
        implicit none
        class(vector), intent(inout) :: me
        integer, intent(in) :: n
 
        integer :: NumBkts
 
        real :: fracbkts
        
        ! required number of new bkts
        fracbkts = n
        numbkts = ceiling(fracbkts/me%BktCap) - me%AllocatedBkts
 
        if (numbkts > 0) then
            call me%create_newbkts(numbkts)
        end if
    end subroutine reserve
 
 
 
 
    subroutine shrinktofit(me)
        implicit none
        class(vector), intent(inout) :: me
 
        type(bktptr), dimension(:), allocatable :: tmp
        integer :: ctr
 
        ! deallocate if used bkts are less than allocated bkts
        if (me%UsedBkts < me%AllocatedBkts) then
            do ctr = me%Size()+1, me%AllocatedBkts
                if (associated(me%VecData(ctr)%pBkt)) deallocate(me%VecData(ctr)%pBkt)
                me%VecData(ctr)%pBkt => null()
            end do
            me%AllocatedBkts = me%UsedBkts
        end if
 
        if (me%AllocatedBkts < 1) then
            ! if all storage deallocated, then set the flag            
            me%StorageAllocated = .false.
            if (allocated(me%VecData)) deallocate(me%VecData, stat=me%status)
        else
            ! shrink the bucket pointer array
            allocate(tmp(1:me%AllocatedBkts), stat=me%status)
            if (me%status == 0) then
                tmp = me%VecData(1:me%AllocatedBkts)
                call move_alloc(from=tmp, to=me%VecData)
            end if
        end if
    end subroutine shrinktofit
    
 
 
    function elem_at(me, Index) result(elem)
        implicit none
        class(vector), intent(inout) :: me
        integer, intent(in) :: index
        class(vecelem), pointer :: elem
        
        integer :: bktnum, offset
 
        ! compute bucket number and offset
        call me%Index2Bkt(index, bktnum, offset)
 
        if (bktnum > 0 .AND. bktnum <= me%UsedBkts &
            .AND. offset > 0 .AND. offset <= me%BktCap) then
            elem => me%VecData(bktnum)%pBkt%bktelem(offset)
        else
            ! incorrect index
            elem => null()
        end if
    end function elem_at
    
 
    function elem_front(me) result(elem)
        implicit none
        class(vector), intent(inout) :: me
        class(vecelem), allocatable :: elem
        
        allocate(elem, source=me%ElemAt(1))
    end function elem_front
 
 
 
    function elem_back(me) result(elem)
        implicit none
        class(vector), intent(inout) :: me
        class(vecelem), allocatable :: elem
 
        integer :: index
        index = (me%UsedBkts-1)*me%BktCap &
                        + me%VecData(me%UsedBkts)%pBkt%bktsz()
        allocate(elem, source=me%ElemAt(index))
    end function elem_back
 
 
 
 
    function vec_slice(me, lower, upper, stride) result(arr)
        implicit none
        class(vector), intent(inout) :: me
 
        integer, intent(in) :: lower
        integer, intent(in) :: upper
        integer, intent(in), optional :: stride
        class(vecelem), dimension(:), allocatable :: arr
 
        integer :: step, ctr, sz, vecsz
        integer, dimension(:), allocatable :: elemindices
 
        if (present(stride)) then
            step = stride
        else
            step = 1
        end if
 
        ! create indices of the requested elements
        elemindices = [(ctr, ctr = lower, upper, step)]
 
        ! allocate memory
        sz = size(elemindices)
        vecsz = me%Size()
        if (sz < 1 .OR. vecsz < 1 &
            .OR. elemindices(1) < 1 .OR. elemindices(1) > vecsz &
            .OR. elemindices(sz) < 1 .OR. elemindices(sz) > vecsz) then
            ! If Vector is empty or requested slice is 0 size then
            ! return 0-sized array
            allocate(invalidvecelem:: arr(0), stat=me%status)
            return
        else
            allocate(arr(sz), mold=me%VecData(1)%pBkt%bktelem(1), &
                                                stat=me%status)
        end if
 
        ! fill the array with data to return
        do ctr = 1, sz
        block
            integer :: bkt, offset
            call me%Index2Bkt(elemindices(ctr), bkt, offset)
            arr(ctr) = me%VecData(bkt)%pBkt%bktelem(offset)
        end block
        end do
    end function vec_slice
 
 
 
 
    function bkt_slice(me, lower, upper) result(ptr)
        implicit none
        class(vector), intent(inout) :: me
 
        integer, intent(in) :: lower
        integer, intent(inout) :: upper
        class(vecelem), dimension(:), pointer :: ptr
 
        integer :: bktl, offsetl, bktu, offsetu, ub, vecsz, ctr
        logical :: boundsvalid
 
        ptr => null()
 
        ! check for bounds
        vecsz = me%Size()
        boundsvalid = .true.
        if (lower < 1 .OR. lower > vecsz) boundsvalid = .false.
        if ((upper > lower .AND. upper > vecsz) &
                .OR. upper < lower .AND. upper < 1) boundsvalid = .false.
 
        if (boundsvalid) then
            call me%Index2Bkt(lower, bktl, offsetl)
            call me%Index2Bkt(upper, bktu, offsetu)
            ! check whether the both bounds lie in the same bucket 
            if (bktl /= bktu) then
                ! truncate the slice to bucket boundary
                if (upper < lower) then
                    ! slice is from lower bound to start of the bucket
                    upper = (bktl-1)*me%BktCap + 1
                    ptr => me%VecData(bktl)%pBkt%bktsliceptr(offsetl,1)
                else
                    ! slice is from lower bound to end of the bucket
                    upper = bktl*me%BktCap
                    ptr => me%VecData(bktl)%pBkt%bktsliceptr(offsetl,me%BktCap)
                end if
            else
                ! slice is from lower to upper bound
                ptr => me%VecData(bktl)%pBkt%bktsliceptr(offsetl,offsetu)
            end if
        end if
    end function bkt_slice
 
 
    function push_back(me, velem) result(Index)
        implicit none
        class(vector), intent(inout) :: me
        class(vecelem), intent(in) :: velem
        integer :: index
        
        integer :: offset
        
        index = 0
        if (.NOT. me%StorageAllocated) then
            ! allocate buckets for the first time
            allocate(me%MoldElem, source=velem)
            call me%create_newbkts(me%NewBktsToAllocate)
            if (me%status /= 0) return
            ! use the newly created first bucket
            me%UsedBkts = 1
        end if
        
        ! extract the index of the last occupied slot in bucket
        if (me%AllocatedBkts > 0 .AND. me%UsedBkts < 1) me%UsedBkts = 1
        offset = me%VecData(me%UsedBkts)%pBkt%bktsz() + 1
        
        ! if bucket is full then allocate more buckets
        if (offset > me%BktCap) then
            ! allocate new buckets
            call me%create_newbkts(me%NewBktsToAllocate)
            if (me%status /= 0) return
            ! use the newly created bucket
            me%UsedBkts = me%UsedBkts + 1
            offset = 1
        end if
 
        ! copy the elem at the back of the bucket
        call me%VecData(me%UsedBkts)%pBkt%add_bktelem(offset, velem)
        index = offset + (me%UsedBkts-1)*me%BktCap
        
    end function push_back
    
 
 
 
    function pop_back(me) result(velem)
        implicit none
        class(vector), intent(inout) :: me
        class(vecelem), allocatable :: velem
        
        integer :: bktind
        
        ! get the last element
        bktind = me%vecdata(me%UsedBkts)%pBkt%bktsz()
        allocate(velem, source=me%VecData(me%UsedBkts)%pBkt%bktelem(bktind))
 
        ! delete this element
        call me%VecData(me%UsedBkts)%pBkt%del_bktelem(bktind)
 
        ! if this bucket is empty, then update used bucket counter
        if (me%vecdata(me%UsedBkts)%pBkt%is_bktempty()) then
            me%UsedBkts = me%UsedBkts - 1
        end if        
    end function pop_back
 
    
 
 
 
    subroutine elem_insert(me, pos, NewElems, count)
        implicit none
        class(vector), intent(inout) :: me
        integer, intent(in) :: pos
        class(vecelem), dimension(:), intent(in) :: NewElems
        integer, intent(in), optional :: count
 
        integer :: countval, reqdslots, emptyslots, newbkts, ctr, sz, vecsz
        integer :: Bkt0, Offset0, Bkt1, Offset1, ctr1, ctr2
        real :: tmp
 
        countval = 1
        if (present(count)) countval = count
 
        ! if empty array is passed, nothing to be done
        sz = size(newelems) 
        vecsz = me%Size()
        if (sz < 1) return
 
        ! if vector is not already allocated, do it now
        if (.NOT. me%StorageAllocated) then
            ! allocate buckets for the first time
            allocate(me%MoldElem, source=newelems(1))
            call me%create_newbkts(me%NewBktsToAllocate)
            if (me%status /= 0) return
            ! use the newly created first bucket
            me%UsedBkts = 1
        end if        
        
        ! check for parameters
        if (pos < 1 .OR. countval < 1 .OR. ((pos-vecsz) > 1)) then
            me%status = -1
            return
        end if
 
        ! Expand Vector for new elements
        reqdslots = countval*sz
        emptyslots = me%Capacity() - me%Size()
        tmp = reqdslots - emptyslots
        newbkts = ceiling(tmp/me%BktCap)
        
        if (newbkts > 0) then
            ! allocate new buckets
            call me%create_newbkts(newbkts)
        end if
                        
        ! First Bucket for the new elements
        call me%Index2Bkt(pos, bkt0, offset0)
        ! First Bucket for the moved elements
        call me%Index2Bkt(pos+countval*sz, bkt1, offset1)
 
        ! Move old element to the new empty locations
        reqdslots = me%Size() - pos + 1
        ctr1 = bkt0
        ctr2 = offset0
        do ctr = 1, reqdslots
            ! Move old element to the new empty location
 
            call me%VecData(bkt1)%pBkt%add_bktelem(offset1, &
                    me%VecData(bkt0)%pBkt%bktelem(offset0))
 
            call me%VecData(bkt0)%pBkt%del_bktelem(offset0)
            
            ! increment counters
            offset0 = offset0 + 1
            offset1 = offset1 + 1
            if (offset0 > me%BktCap) then
                offset0 = 1
                bkt0 = bkt0 + 1
            end if
            if (offset1 > me%BktCap) then
                offset1 = 1
                bkt1 = bkt1 + 1
            end if
        end do
 
        ! copy the new element in the old location
        bkt0 = ctr1
        offset0 = ctr2
        ctr1 = 1
        do ctr = 1, countval*sz
            ! copy the new element in the old location
            call me%VecData(bkt0)%pBkt%add_bktelem(offset0, newelems(ctr1))
            ! increment counters
            ctr1 = ctr1 + 1
            if (ctr1 > sz) ctr1 = 1
            offset0 = offset0 + 1
            if (offset0 > me%BktCap) then
                offset0 = 1
                bkt0 = bkt0 + 1
            end if            
        end do
        
        ! update the buckets used
        me%UsedBkts = me%usedBkts + newbkts
 
    end subroutine elem_insert
 
 
 
 
 
    subroutine elem_erase(me, lower, upper)
        implicit none
        class(vector), intent(inout) :: me
 
        integer, intent(In) :: lower
        integer, intent(In), optional :: upper
 
        integer :: sz, ctr, upperval
        integer :: Bkt0, Offset0, Bkt1, Offset1
 
        ! parameter checks
        sz = me%Size()
        if (lower < 1 .OR. lower > sz .OR. sz < 1) return
 
        if (present(upper)) then
            if (lower > upper) return
        end if
 
        ! Location of the first element to be deleted
        call me%Index2Bkt(lower, bkt0, offset0)
 
        ! Location of the element just after the last element to be deleted
        if (present(upper)) then
            upperval = upper + 1
            call me%Index2Bkt(upperval, bkt1, offset1)
        else
            upperval = lower + 1
            bkt1 = bkt0
            offset1 = offset0 + 1
            if (offset1 > me%BktCap) then
                offset1 = 1
                bkt1 = bkt1 + 1
            end if
        end if
 
        ! shift the other elements one by one
        do ctr = 1, (sz - upperval + 1)
            ! shift
            call me%VecData(bkt0)%pBkt%add_bktelem(offset0, &
                            me%VecData(bkt1)%pBkt%bktelem(offset1))
            
            ! increment counters
            offset0 = offset0 + 1
            offset1 = offset1 + 1
            if (offset0 > me%BktCap) then
                offset0 = 1
                bkt0 = bkt0 + 1
            end if         
            if (offset1 > me%BktCap) then
                offset1 = 1
                bkt1 = bkt1 + 1
            end if    
        end do
 
        ! Clear the empty slots in the last partially filled bkt
        if (offset0 /= 1) then
            do ctr = offset0, me%BktCap
                call me%VecData(bkt0)%pBkt%del_bktelem(ctr)
            end do
            bkt0 = bkt0 + 1
        end if
        ! clear the extra buckets starting from Bkt0+1
        do ctr = bkt0, bkt1
            call me%VecData(ctr)%pBkt%bktclear()            
        end do
        ! update number of used buckets
        me%UsedBkts = bkt0 - 1
 
    end subroutine elem_erase
 
 
 
 
    subroutine clear(me)
        implicit none
        class(vector), intent(inout) :: me
 
        integer :: ctr
        ! clear bucket slots
        do ctr = 1, me%UsedBkts
            call me%VecData(ctr)%pBkt%bktclear()
        end do
        ! used buckets are 0 now
        me%UsedBkts = 0
    end subroutine clear
 
    
 
 
    subroutine create_newbkts(me, NumBkts)
        implicit none
        class(vector), intent(inout) :: me
 
        integer, intent(in) :: NumBkts
 
        type(bktptr), dimension(:), allocatable :: tmp
        integer :: ctr
 
        ! allocate new bucket array
        allocate(tmp(me%AllocatedBkts+numbkts), stat=me%status)
            
        if (me%status == 0) then
            ! if vector already has buckets
            if (me%StorageAllocated) then
                ! copy the previous bucket pointers
                tmp(1:me%AllocatedBkts) = me%VecData
            end if
 
            ! expand the bucket array
            call move_alloc(from=tmp, to=me%VecData)
 
            ! allocate storage for new buckets
            do ctr = 1, numbkts
                allocate(me%VecData(me%AllocatedBkts+ctr)%pBkt, stat=me%status)
                call me%VecData(me%AllocatedBkts+ctr)%pbkt%bktinit(me%status, &
                                                me%BktCap, me%MoldElem)
                if (me%status /= 0) exit
            end do
            
            ! If the intended number of buckets are not allocated, init failed
            if (ctr > numbkts) then
                me%AllocatedBkts = me%AllocatedBkts + ctr - 1
                me%StorageAllocated = .true.
            else
                me%status = -1
            end if
        end if
    end subroutine create_newbkts
 
 
 
    pure subroutine index2bkt(me, Index, Bkt, BktOffset)
        implicit none
        class(vector), intent(in) :: me
 
        integer, intent(in) :: index
        integer, intent(out) :: bkt
        integer, intent(out) :: bktoffset
 
        real :: frac
        
        ! Bucket to which this index belongs
        frac = index
        frac = frac/me%BktCap
        bkt = ceiling(frac)
 
        ! Offset into the bucket
        bktoffset = index - (bkt-1)*me%BktCap
    end subroutine
 
 
    ! Do nothing for the invalid element assignement
    subroutine assign_invalidelem(lhs, rhs)
        implicit none
        class(invalidvecelem), intent(out) :: lhs
        class(vecelem), intent(in) :: rhs
    end subroutine assign_invalidelem
    
 
    subroutine assignvector(lhs, rhs)
        implicit none
        class(vector), intent(out) :: lhs
        class(vector), intent(in) :: rhs
 
        integer :: ctr
 
        ! we assign the contents by moving all the buckets of rhs to lhs
 
        ! allocate memory for buckets array
        allocate(lhs%VecData(size(rhs%VecData)))
 
        ! create buckets and mold elem
        allocate(lhs%MoldElem, source=rhs%MoldElem)
        do ctr = 1, rhs%AllocatedBkts
            allocate(lhs%VecData(ctr)%pBkt, source=rhs%VecData(ctr)%pBkt)
        end do
        
        ! copy Vector state
        lhs%status              = rhs%status
        lhs%StorageAllocated    = rhs%StorageAllocated
        lhs%NewBktsToAllocate   = rhs%NewBktsToAllocate
        lhs%BktCap              = rhs%BktCap
        lhs%UsedBkts            = rhs%UsedBkts
        lhs%AllocatedBkts       = rhs%AllocatedBkts
        
    end subroutine assignvector    
 
    
    subroutine destroy(me)
        implicit none
        type(vector), intent(inout) :: me
    
        integer :: ctr
        
        ! free up memory held up by all the buckets
        do ctr = 1, size(me%VecData)
            if (associated(me%VecData(ctr)%pBkt)) deallocate(me%VecData(ctr)%pBkt)
            me%VecData(ctr)%pBkt => null()
        end do
    end subroutine destroy
 
 
 
    subroutine bktinit(me, status, cap, mold_elem)
        implicit none
        class(bkt), intent(inout) :: me
        integer, intent(out) :: status
        integer, intent(in) :: cap
        class(vecelem), intent(in) :: mold_elem
 
        allocate(me%SlotFree(cap), stat=status)
        allocate(me%BktData(cap), stat=status, mold=mold_elem)        
        me%SlotFree = .true.
    end subroutine bktinit
 
 
 
    subroutine add_bktelem(me, offset, elem)
        implicit none
        class(bkt), intent(inout) :: me
        integer, intent(in) :: offset
        class(vecelem), intent(in) :: elem
 
        me%BktData(offset) = elem
        me%SlotFree(offset) = .false.
    end subroutine add_bktelem
 
 
 
    subroutine del_bktelem(me, offset)
        implicit none
        class(bkt), intent(inout) :: me
        integer, intent(in) :: offset
 
        me%SlotFree(offset) = .true.
    end subroutine del_bktelem
 
 
    subroutine bktclear(me)
        implicit none
        class(bkt), intent(inout) :: me
 
        me%SlotFree = .true.
    end subroutine bktclear
 
 
 
    function bktelem(me, offset)
        implicit none
        class(bkt), intent(in), target :: me
        integer, intent(in) :: offset
        class(vecelem), pointer :: bktelem
 
        if (.NOT. me%SlotFree(offset)) then
            bktelem => me%BktData(offset)
        else
            bktelem => null()
        end if
    end function bktelem
 
 
 
    function bktsliceptr(me, start_ind, end_ind)
        implicit none
        class(bkt), intent(in), target :: me
        integer, intent(in) :: start_ind, end_ind
        class(vecelem), dimension(:), pointer :: bktsliceptr
 
        integer :: stride
 
        bktsliceptr => null()
 
        stride = 1
        if (start_ind > end_ind) stride = -1
 
        if (any(me%SlotFree(start_ind:end_ind:stride))) return
            
        bktsliceptr => me%BktData(start_ind:end_ind:stride)
    end function bktsliceptr
 
 
 
    pure function is_bktempty(me)
        implicit none
        class(bkt), intent(in) :: me
        logical :: is_bktempty
 
        is_bktempty = .false.
        if (all(me%SlotFree)) is_bktempty = .true.
    end function is_bktempty
 
 
 
    pure function bktsz(me)
        implicit none
        class(bkt), intent(in) :: me
        integer :: bktsz
        bktsz = count(.NOT. me%SlotFree)
    end function bktsz
 
 
 
end module vectors