fix issues in most demo programs

Author: jvdp1

CMakeLists.txt

@@ -49,6 +49,7 @@ if(NOT FYPP)
 endif()
 
 add_subdirectory(src)
+add_subdirectory(test)
 
 install(EXPORT ${PROJECT_NAME}-targets
         NAMESPACE ${PROJECT_NAME}::

test/CMakeLists.txt

@@ -0,0 +1 @@
+add_subdirectory(example)

test/example/CMakeLists.txt

@@ -0,0 +1,32 @@
+macro(ADD_DEMO name)
+    add_executable(demo_${name} demo_${name}.f90)
+    target_link_libraries(demo_${name} "${PROJECT_NAME}")
+#    add_test(NAME ${name}
+#             COMMAND $<TARGET_FILE:demo_${name}> ${CMAKE_CURRENT_BINARY_DIR}
+#             WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR})
+endmacro(ADD_DEMO)
+
+add_subdirectory(array)
+add_subdirectory(ascii)
+add_subdirectory(bitsets)
+add_subdirectory(error)
+add_subdirectory(hashmaps)
+add_subdirectory(hash_procedures)
+add_subdirectory(io)
+add_subdirectory(linalg)
+add_subdirectory(logger)
+add_subdirectory(math)
+add_subdirectory(optval)
+add_subdirectory(quadrature)
+add_subdirectory(random)
+add_subdirectory(selection)
+add_subdirectory(sorting)
+add_subdirectory(specialfunctions_gamma)
+add_subdirectory(stats)
+add_subdirectory(stats_distribution_exponential)
+add_subdirectory(stats_distribution_normal)
+add_subdirectory(stats_distribution_uniform)
+add_subdirectory(stringlist_type)
+add_subdirectory(strings)
+add_subdirectory(string_type)
+add_subdirectory(version)

test/example/array/CMakeLists.txt

@@ -0,0 +1,2 @@
+#ADD_DEMO(falseloc)
+ADD_DEMO(trueloc)

test/example/ascii/CMakeLists.txt

@@ -0,0 +1,5 @@
+ADD_DEMO(ascii_reverse)
+ADD_DEMO(ascii_to_lower)
+ADD_DEMO(ascii_to_sentence)
+ADD_DEMO(ascii_to_title)
+ADD_DEMO(ascii_to_upper)

test/example/ascii/demo_reverse.f90 renamed to test/example/ascii/demo_ascii_reverse.f90

@@ -0,0 +1,30 @@
+ADD_DEMO(bitsets_all)
+ADD_DEMO(bitsets_and)
+ADD_DEMO(bitsets_and_not)
+ADD_DEMO(bitsets_any)
+ADD_DEMO(bitsets_assignment)
+ADD_DEMO(bitsets_bit_count)
+ADD_DEMO(bitsets_bits)
+ADD_DEMO(bitsets_clear)
+ADD_DEMO(bitsets_equality)
+ADD_DEMO(bitsets_extract)
+ADD_DEMO(bitsets_flip)
+ADD_DEMO(bitsets_from_string)
+ADD_DEMO(bitsets_ge)
+ADD_DEMO(bitsets_gt)
+ADD_DEMO(bitsets_inequality)
+ADD_DEMO(bitsets_init)
+ADD_DEMO(bitsets_input)
+ADD_DEMO(bitsets_le)
+ADD_DEMO(bitsets_lt)
+ADD_DEMO(bitsets_none)
+ADD_DEMO(bitsets_not)
+ADD_DEMO(bitsets_or)
+ADD_DEMO(bitsets_output)
+ADD_DEMO(bitsets_read_bitset)
+ADD_DEMO(bitsets_set)
+ADD_DEMO(bitsets_test)
+ADD_DEMO(bitsets_to_string)
+ADD_DEMO(bitsets_value)
+ADD_DEMO(bitsets_write_bitset)
+ADD_DEMO(bitsets_xor)

test/example/ascii/demo_to_lower.f90 renamed to test/example/ascii/demo_ascii_to_lower.f90

@@ -4,14 +4,14 @@ program demo_and
 call set0 % init(166)
 call set1 % init(166)
 call and( set0, set1 ) ! none none
-if ( none(set0) ) write(*,*) 'First test of AND worked.'
+if ( set0 % none() ) write(*,*) 'First test of AND worked.'
 call set0 % not()
 call and( set0, set1 ) ! all none
-if ( none(set0) ) write(*,*) 'Second test of AND worked.'
+if ( set0 % none() ) write(*,*) 'Second test of AND worked.'
 call set1 % not()
 call and( set0, set1 ) ! none all
-if ( none(set0) ) write(*,*) 'Third test of AND worked.'
+if ( set0 % none() ) write(*,*) 'Third test of AND worked.'
 call set0 % not()
 call and( set0, set1 ) ! all all
-if ( all(set0) ) write(*,*) 'Fourth test of AND worked.'
+if ( set0 % all() ) write(*,*) 'Fourth test of AND worked.'
 end program demo_and

test/example/ascii/demo_to_sentence.f90 renamed to test/example/ascii/demo_ascii_to_sentence.f90

@@ -4,15 +4,15 @@ program demo_and_not
 call set0 % init(166)
 call set1 % init(166)
 call and_not( set0, set1 ) ! none none
-if ( none(set0) ) write(*,*) 'First test of AND_NOT worked.'
+if ( set0 % none() ) write(*,*) 'First test of AND_NOT worked.'
 call set0 % not()
 call and_not( set0, set1 ) ! all none
-if ( all(set0) ) write(*,*) 'Second test of AND_NOT worked.'
+if ( set0 % all() ) write(*,*) 'Second test of AND_NOT worked.'
 call set0 % not()
 call set1 % not()
 call and_not( set0, set1 ) ! none all
-if ( none(set0) ) write(*,*) 'Third test of AND_NOT worked.'
+if ( set0 % none() ) write(*,*) 'Third test of AND_NOT worked.'
 call set0 % not()
 call and_not( set0, set1 ) ! all all
-if ( none(set0) ) write(*,*) 'Fourth test of AND_NOT worked.'
+if ( set0 % none() ) write(*,*) 'Fourth test of AND_NOT worked.'
 end program demo_and_not

test/example/ascii/demo_to_title.f90 renamed to test/example/ascii/demo_ascii_to_title.f90

@@ -1,15 +1,17 @@
 program demo_assignment
 use stdlib_bitsets
+use stdlib_kinds, only: int8, int32
+implicit none
 logical(int8)  :: logical1(64) = .true.
 logical(int32), allocatable :: logical2(:)
 type(bitset_64) :: set0, set1
 set0 = logical1
 if ( set0 % bits() /= 64 ) then
-error stop procedure // &
+error stop &
 ' initialization with logical(int8) failed to set' // &
 ' the right size.'
 else if ( .not. set0 % all() ) then
-error stop procedure // ' initialization with' // &
+error stop ' initialization with' // &
 ' logical(int8) failed to set the right values.'
 else
 write(*,*) 'Initialization with logical(int8) succeeded.'

test/example/ascii/demo_to_upper.f90 renamed to test/example/ascii/demo_ascii_to_upper.f90

@@ -6,7 +6,7 @@ program demo_from_string
 call set0 % from_string( bits_all )
 if ( bits(set0) /= 33 ) then
 error stop "FROM_STRING failed to interpret " // &
-'BITS_ALL's size properly."
+"BITS_ALL's size properly."
 else if ( .not. set0 % all() ) then
 error stop "FROM_STRING failed to interpret" // &
 "BITS_ALL's value properly."

test/example/bitsets/CMakeLists.txt

@@ -1,4 +1,6 @@
 program demo_input
+use stdlib_bitsets
+implicit none
 character(*), parameter :: &
 bits_0   = '000000000000000000000000000000000', &
 bits_1   = '000000000000000000000000000000001', &

test/example/bitsets/demo_all.f90 renamed to test/example/bitsets/demo_bitsets_all.f90

@@ -4,15 +4,15 @@ program demo_or
 call set0 % init(166)
 call set1 % init(166)
 call or( set0, set1 ) ! none none
-if ( none(set0) ) write(*,*) 'First test of OR worked.'
+if ( set0 % none() ) write(*,*) 'First test of OR worked.'
 call set0 % not()
 call or( set0, set1 ) ! all none
-if ( all(set0) ) write(*,*) 'Second test of OR worked.'
+if ( set0 % all() ) write(*,*) 'Second test of OR worked.'
 call set0 % not()
 call set1 % not()
 call or( set0, set1 ) ! none all
-if ( all(set0) ) write(*,*) 'Third test of OR worked.'
+if ( set0 % all() ) write(*,*) 'Third test of OR worked.'
 call set0 % not()
 call or( set0, set1 ) ! all all
-if ( all(set0) ) write(*,*) 'Fourth test of OR worked.'
+if ( set0 % all() ) write(*,*) 'Fourth test of OR worked.'
 end program demo_or

test/example/bitsets/demo_and.f90 renamed to test/example/bitsets/demo_bitsets_and.f90

@@ -1,4 +1,6 @@
 program demo_output
+use stdlib_bitsets
+implicit none
 character(*), parameter :: &
 bits_0   = '000000000000000000000000000000000', &
 bits_1   = '000000000000000000000000000000001', &

test/example/bitsets/demo_and_not.f90 renamed to test/example/bitsets/demo_bitsets_and_not.f90

@@ -1,10 +1,12 @@
 program demo_read_bitset
+use stdlib_bitsets
+implicit none
 character(*), parameter :: &
 bits_0   = 'S33B000000000000000000000000000000000', &
 bits_1   = 'S33B000000000000000000000000000000001', &
-bits_33  = 'S33B100000000000000000000000000000000'
+bits_2   = 'S33B100000000000000000000000000000000'
 character(:), allocatable :: test_0, test_1, test_2
-integer :: unit
+integer :: unit, status
 type(bitset_64) :: set0, set1, set2, set3, set4, set5
 call set0 % read_bitset( bits_0, status )
 call set1 % read_bitset( bits_1, status )
@@ -28,6 +30,6 @@ program demo_read_bitset
 call set4 % read_bitset(unit, advance='no')
 call set5 % read_bitset(unit)
 if ( set3 == set0 .and. set4 == set1 .and. set5 == set2 ) then
-write(*,*) WRITE_BITSET to READ_BITSET through unit worked.'
+write(*,*) 'WRITE_BITSET to READ_BITSET through unit worked.'
 end if
 end program demo_read_bitset

test/example/bitsets/demo_any.f90 renamed to test/example/bitsets/demo_bitsets_any.f90

@@ -1,10 +1,12 @@
 program demo_write_bitset
+use stdlib_bitsets
+implicit none
 character(*), parameter :: &
 bits_0   = 'S33B000000000000000000000000000000000', &
 bits_1   = 'S33B000000000000000000000000000000001', &
-bits_33  = 'S33B100000000000000000000000000000000'
+bits_2   = 'S33B100000000000000000000000000000000'
 character(:), allocatable :: test_0, test_1, test_2
-integer :: unit
+integer :: unit, status
 type(bitset_64) :: set0, set1, set2, set3, set4, set5
 call set0 % read_bitset( bits_0, status )
 call set1 % read_bitset( bits_1, status )
@@ -28,6 +30,6 @@ program demo_write_bitset
 call set4 % read_bitset(unit, advance='no')
 call set5 % read_bitset(unit)
 if ( set3 == set0 .and. set4 == set1 .and. set5 == set2 ) then
-write(*,*) WRITE_BITSET to READ_BITSET through unit worked.'
+write(*,*) 'WRITE_BITSET to READ_BITSET through unit worked.'
 end if
 end program demo_write_bitset

test/example/bitsets/demo_assignment.f90 renamed to test/example/bitsets/demo_bitsets_assignment.f90

@@ -4,15 +4,15 @@ program demo_xor
 call set0 % init(166)
 call set1 % init(166)
 call xor( set0, set1 ) ! none none
-if ( none(set0) ) write(*,*) 'First test of XOR worked.'
+if ( set0 % none() ) write(*,*) 'First test of XOR worked.'
 call set0 % not()
 call xor( set0, set1 ) ! all none
-if ( all(set0) ) write(*,*) 'Second test of XOR worked.'
+if ( set0 % all() ) write(*,*) 'Second test of XOR worked.'
 call set0 % not()
 call set1 % not()
 call xor( set0, set1 ) ! none all
-if ( all(set0) ) write(*,*) 'Third test of XOR worked.'
+if ( set0 % all() ) write(*,*) 'Third test of XOR worked.'
 call set0 % not()
 call xor( set0, set1 ) ! all all
-if ( none(set0) ) write(*,*) 'Fourth test of XOR worked.'
+if ( set0 % none() ) write(*,*) 'Fourth test of XOR worked.'
 end program demo_xor

test/example/bitsets/demo_bit_count.f90 renamed to test/example/bitsets/demo_bitsets_bit_count.f90

@@ -0,0 +1,6 @@
+ADD_DEMO(check1)
+ADD_DEMO(check2)
+ADD_DEMO(check3)
+ADD_DEMO(check4)
+ADD_DEMO(error_stop1)
+ADD_DEMO(error_stop2)

test/example/bitsets/demo_bits.f90 renamed to test/example/bitsets/demo_bitsets_bits.f90

@@ -0,0 +1,13 @@
+ADD_DEMO(fibonacci_hash_64)
+ADD_DEMO(fibonacci_hash)
+ADD_DEMO(fnv_1a_hash_64)
+ADD_DEMO(fnv_1a_hash)
+ADD_DEMO(fnv_1_hash_64)
+ADD_DEMO(fnv_1_hash)
+ADD_DEMO(nmhash32)
+ADD_DEMO(nmhash32x)
+ADD_DEMO(pengy_hash)
+ADD_DEMO(spooky_hash)
+ADD_DEMO(universal_mult_hash_64)
+ADD_DEMO(universal_mult_hash)
+ADD_DEMO(water_hash)

test/example/bitsets/demo_clear.f90 renamed to test/example/bitsets/demo_bitsets_clear.f90

@@ -1,5 +1,5 @@
 program demo_universal_mult_hash_64
-use stdlib_hash_32bit, only: odd_random_integer, &
+use stdlib_hash_64bit, only: odd_random_integer, &
 universal_mult_hash
 use iso_fortran_env, only: int64
 implicit none

test/example/bitsets/demo_equality.f90 renamed to test/example/bitsets/demo_bitsets_equality.f90

@@ -0,0 +1,27 @@
+ADD_DEMO(hashmaps_calls)
+ADD_DEMO(hashmaps_copy_key)
+#ADD_DEMO(hashmaps_copy_other)
+ADD_DEMO(hashmaps_entries)
+ADD_DEMO(hashmaps_equal_keys)
+ADD_DEMO(hashmaps_fnv_1a_hasher)
+ADD_DEMO(hashmaps_fnv_1_hasher)
+ADD_DEMO(hashmaps_free_key)
+ADD_DEMO(hashmaps_free_other)
+ADD_DEMO(hashmaps_get)
+ADD_DEMO(hashmaps_get_other_data)
+ADD_DEMO(hashmaps_hasher_fun)
+ADD_DEMO(hashmaps_init)
+ADD_DEMO(hashmaps_key_test)
+ADD_DEMO(hashmaps_loading)
+ADD_DEMO(hashmaps_map_entry)
+ADD_DEMO(hashmaps_num_slots)
+ADD_DEMO(hashmaps_probes)
+ADD_DEMO(hashmaps_rehash)
+ADD_DEMO(hashmaps_remove)
+ADD_DEMO(hashmaps_seeded_nmhash32_hasher)
+ADD_DEMO(hashmaps_seeded_nmhash32x_hasher)
+ADD_DEMO(hashmaps_seeded_water_hasher)
+ADD_DEMO(hashmaps_set)
+ADD_DEMO(hashmaps_set_other_data)
+ADD_DEMO(hashmaps_slots_bits)
+ADD_DEMO(hashmaps_total_depth)

test/example/bitsets/demo_extract.f90 renamed to test/example/bitsets/demo_bitsets_extract.f90

@@ -3,7 +3,7 @@ program demo_calls
 use stdlib_hashmap_wrappers, only: fnv_1_hasher
 implicit none
 type(chaining_hashmap_type) :: map
-type(int_calls) :: initial_calls
+integer(int_calls) :: initial_calls
 call map % init( fnv_1_hasher )
 initial_calls = map % calls()
 print *, "INITIAL_CALLS =  ", initial_calls

test/example/bitsets/demo_flip.f90 renamed to test/example/bitsets/demo_bitsets_flip.f90

@@ -1,12 +1,12 @@
 program demo_copy_key
 use stdlib_hashmap_wrappers, only: &
-copy_key, operator(==), key_type
+copy_key, operator(==), key_type, set
 use iso_fortran_env, only: int8
 implicit none
 integer(int8) :: i, value(15)
 type(key_type) :: old_key, new_key
 value = [(i, i = 1, 15)]
-call set( key_out, value )
-call copy_key( key_out, new_key )
+call set( old_key, value )
+call copy_key( old_key, new_key )
 print *, "old_key == new_key = ", old_key == new_key
 end program demo_copy_key

test/example/bitsets/demo_from_string.f90 renamed to test/example/bitsets/demo_bitsets_from_string.f90

@@ -4,20 +4,20 @@ program demo_copy_other
 use iso_fortran_env, only: int8
 implicit none
 type(other_type) :: other_in, other_out
-integer(int_8) :: i
+integer(int8) :: i
 class(*), allocatable :: dummy
 type dummy_type
 integer(int8) :: value(15)
 end type
 type(dummy_type) :: dummy_val
 do i=1, 15
-dummy_val % value1(i) = i
+dummy_val % value(i) = i
 end do
 allocate(other_in % value, source=dummy_val)
 call copy_other( other_in, other_out )
 select type(other_out)
-	  type(dummy_type)
+typeis (dummy_type)
 print *, "other_in == other_out = ", &
-all( dummy_val % value == other_out % value )
+all( other_in % value == other_out % value )
 end select
 end program demo_copy_other

test/example/bitsets/demo_ge.f90 renamed to test/example/bitsets/demo_bitsets_ge.f90

@@ -3,7 +3,7 @@ program demo_entries
 use stdlib_hashmap_wrappers, only: fnv_1_hasher
 implicit none
 type(open_hashmap_type) :: map
-type(int_index) :: initial_entries
+integer(int_index) :: initial_entries
 call map % init( fnv_1_hasher )
 initial_entries = map % entries ()
 print *, "INITIAL_ENTRIES =  ", initial_entries

test/example/bitsets/demo_gt.f90 renamed to test/example/bitsets/demo_bitsets_gt.f90

@@ -1,7 +1,6 @@
 program demo_fnv_1_hasher
-use stdlib_hashmap_wrappers, only: &
-fnv_1_hasher, key_type, set
-use iso_fortran_env, only: int32
+use stdlib_hashmap_wrappers, only: fnv_1_hasher, key_type, set
+use iso_fortran_env, only: int8, int32
 implicit none
 integer(int8), allocatable :: array1(:)
 integer(int32) :: hash

test/example/bitsets/demo_inequality.f90 renamed to test/example/bitsets/demo_bitsets_inequality.f90

@@ -1,7 +1,7 @@
 program demo_fnv_1a_hasher
 use stdlib_hashmap_wrappers, only: &
 fnv_1a_hasher, key_type, set
-use iso_fortran_env, only: int32
+use iso_fortran_env, only: int8, int32
 implicit none
 integer(int8), allocatable :: array1(:)
 integer(int32) :: hash