Extraction of the demo programs from the specs

test/example/array/demo_falseloc.f90

@@ -1,8 +1,8 @@
 program demo_falseloc
-use stdlib_array, only : falseloc
-implicit none
-real, allocatable :: array(:)
-allocate(array(-200:200))
-call random_number(array)
-array(falseloc(array < 0.5), lbound(array)) = 0.0
+    use stdlib_array, only: falseloc
+    implicit none
+    real, allocatable :: array(:)
+    allocate (array(-200:200))
+    call random_number(array)
+    array(falseloc(array < 0.5), lbound(array)) = 0.0
 end program demo_falseloc

test/example/array/demo_trueloc.f90

@@ -1,8 +1,8 @@
 program demo_trueloc
-use stdlib_array, only : trueloc
-implicit none
-real, allocatable :: array(:)
-allocate(array(500))
-call random_number(array)
-array(trueloc(array > 0.5)) = 0.0
+    use stdlib_array, only: trueloc
+    implicit none
+    real, allocatable :: array(:)
+    allocate (array(500))
+    call random_number(array)
+    array(trueloc(array > 0.5)) = 0.0
 end program demo_trueloc

test/example/ascii/demo_ascii_reverse.f90

@@ -1,5 +1,5 @@
 program demo_reverse
-use stdlib_ascii, only : reverse
-implicit none
-print'(a)', reverse("Hello, World!") ! returns "!dlroW ,olleH"
+    use stdlib_ascii, only: reverse
+    implicit none
+    print'(a)', reverse("Hello, World!") ! returns "!dlroW ,olleH"
 end program demo_reverse

test/example/ascii/demo_ascii_to_lower.f90

@@ -1,5 +1,5 @@
 program demo_to_lower
-use stdlib_ascii, only : to_lower
-implicit none
-print'(a)', to_lower("HELLo!") ! returns "hello!"
+    use stdlib_ascii, only: to_lower
+    implicit none
+    print'(a)', to_lower("HELLo!") ! returns "hello!"
 end program demo_to_lower

test/example/ascii/demo_ascii_to_sentence.f90

@@ -1,7 +1,7 @@
 program demo_to_sentence
-use stdlib_ascii, only : to_sentence
-implicit none
-print*, to_sentence("hello!") ! returns "Hello!"
-print*, to_sentence("'enquoted'") ! returns "'Enquoted'"
-print*, to_sentence("1st")  ! returns "1st"
+    use stdlib_ascii, only: to_sentence
+    implicit none
+    print *, to_sentence("hello!") ! returns "Hello!"
+    print *, to_sentence("'enquoted'") ! returns "'Enquoted'"
+    print *, to_sentence("1st")  ! returns "1st"
 end program demo_to_sentence

test/example/ascii/demo_ascii_to_title.f90

@@ -1,7 +1,7 @@
 program demo_to_title
-use stdlib_ascii, only : to_title
-implicit none
-print*, to_title("hello there!") ! returns "Hello There!"
-print*, to_title("'enquoted'") ! returns "'Enquoted'"
-print*, to_title("1st")  ! returns "1st"
+    use stdlib_ascii, only: to_title
+    implicit none
+    print *, to_title("hello there!") ! returns "Hello There!"
+    print *, to_title("'enquoted'") ! returns "'Enquoted'"
+    print *, to_title("1st")  ! returns "1st"
 end program demo_to_title

test/example/ascii/demo_ascii_to_upper.f90

@@ -1,5 +1,5 @@
 program demo_to_upper
-use stdlib_ascii, only : to_upper
-implicit none
-print'(a)', to_upper("hello!") ! returns "HELLO!"
+    use stdlib_ascii, only: to_upper
+    implicit none
+    print'(a)', to_upper("hello!") ! returns "HELLO!"
 end program demo_to_upper

test/example/bitsets/demo_bitsets_all.f90

@@ -1,14 +1,14 @@
 program demo_all
-use stdlib_bitsets
-character(*), parameter :: &
-bits_all = '111111111111111111111111111111111'
-type(bitset_64) :: set0
-call set0 % from_string( bits_all )
-if ( .not. set0 % all() ) then
-error stop "FROM_STRING failed to interpret" // &
-"BITS_ALL's value properly."
-else
-write(*,*) "FROM_STRING transferred BITS_ALL properly" // &
-" into set0."
-end if
+    use stdlib_bitsets
+    character(*), parameter :: &
+        bits_all = '111111111111111111111111111111111'
+    type(bitset_64) :: set0
+    call set0%from_string(bits_all)
+    if (.not. set0%all()) then
+        error stop "FROM_STRING failed to interpret"// &
+            "BITS_ALL's value properly."
+    else
+        write (*, *) "FROM_STRING transferred BITS_ALL properly"// &
+            " into set0."
+    end if
 end program demo_all

test/example/bitsets/demo_bitsets_and.f90

@@ -1,17 +1,17 @@
 program demo_and
-use stdlib_bitsets
-type(bitset_large) :: set0, set1
-call set0 % init(166)
-call set1 % init(166)
-call and( set0, set1 ) ! none none
-if ( set0 % none() ) write(*,*) 'First test of AND worked.'
-call set0 % not()
-call and( set0, set1 ) ! all none
-if ( set0 % none() ) write(*,*) 'Second test of AND worked.'
-call set1 % not()
-call and( set0, set1 ) ! none all
-if ( set0 % none() ) write(*,*) 'Third test of AND worked.'
-call set0 % not()
-call and( set0, set1 ) ! all all
-if ( set0 % all() ) write(*,*) 'Fourth test of AND worked.'
+    use stdlib_bitsets
+    type(bitset_large) :: set0, set1
+    call set0%init(166)
+    call set1%init(166)
+    call and(set0, set1) ! none none
+    if (set0%none()) write (*, *) 'First test of AND worked.'
+    call set0%not()
+    call and(set0, set1) ! all none
+    if (set0%none()) write (*, *) 'Second test of AND worked.'
+    call set1%not()
+    call and(set0, set1) ! none all
+    if (set0%none()) write (*, *) 'Third test of AND worked.'
+    call set0%not()
+    call and(set0, set1) ! all all
+    if (set0%all()) write (*, *) 'Fourth test of AND worked.'
 end program demo_and

test/example/bitsets/demo_bitsets_and_not.f90

@@ -1,18 +1,18 @@
 program demo_and_not
-use stdlib_bitsets
-type(bitset_large) :: set0, set1
-call set0 % init(166)
-call set1 % init(166)
-call and_not( set0, set1 ) ! none none
-if ( set0 % none() ) write(*,*) 'First test of AND_NOT worked.'
-call set0 % not()
-call and_not( set0, set1 ) ! all none
-if ( set0 % all() ) write(*,*) 'Second test of AND_NOT worked.'
-call set0 % not()
-call set1 % not()
-call and_not( set0, set1 ) ! none all
-if ( set0 % none() ) write(*,*) 'Third test of AND_NOT worked.'
-call set0 % not()
-call and_not( set0, set1 ) ! all all
-if ( set0 % none() ) write(*,*) 'Fourth test of AND_NOT worked.'
+    use stdlib_bitsets
+    type(bitset_large) :: set0, set1
+    call set0%init(166)
+    call set1%init(166)
+    call and_not(set0, set1) ! none none
+    if (set0%none()) write (*, *) 'First test of AND_NOT worked.'
+    call set0%not()
+    call and_not(set0, set1) ! all none
+    if (set0%all()) write (*, *) 'Second test of AND_NOT worked.'
+    call set0%not()
+    call set1%not()
+    call and_not(set0, set1) ! none all
+    if (set0%none()) write (*, *) 'Third test of AND_NOT worked.'
+    call set0%not()
+    call and_not(set0, set1) ! all all
+    if (set0%none()) write (*, *) 'Fourth test of AND_NOT worked.'
 end program demo_and_not

test/example/bitsets/demo_bitsets_any.f90

@@ -1,15 +1,15 @@
 program demo_any
-use stdlib_bitsets
-character(*), parameter :: &
-bits_0 = '0000000000000000000'
-type(bitset_64) :: set0
-call set0 % from_string( bits_0 )
-if ( .not. set0 % any() ) then
-write(*,*) "FROM_STRING interpreted " // &
-"BITS_0's value properly."
-end if
-call set0 % set(5)
-if ( set0 % any() ) then
-write(*,*) "ANY interpreted SET0's value properly."
-end if
+    use stdlib_bitsets
+    character(*), parameter :: &
+        bits_0 = '0000000000000000000'
+    type(bitset_64) :: set0
+    call set0%from_string(bits_0)
+    if (.not. set0%any()) then
+        write (*, *) "FROM_STRING interpreted "// &
+            "BITS_0's value properly."
+    end if
+    call set0%set(5)
+    if (set0%any()) then
+        write (*, *) "ANY interpreted SET0's value properly."
+    end if
 end program demo_any

test/example/bitsets/demo_bitsets_assignment.f90

@@ -1,26 +1,26 @@
 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 &
-' initialization with logical(int8) failed to set' // &
-' the right size.'
-else if ( .not. set0 % all() ) then
-error stop ' initialization with' // &
-' logical(int8) failed to set the right values.'
-else
-write(*,*) 'Initialization with logical(int8) succeeded.'
-end if
-set1 = set0
-if ( set1 == set0 ) &
-write(*,*) 'Initialization by assignment succeeded'
-logical2 = set1
-if ( all( logical2 ) ) then
-write(*,*) 'Initialization of logical(int32) succeeded.'
-end if
+    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 &
+            ' initialization with logical(int8) failed to set'// &
+            ' the right size.'
+    else if (.not. set0%all()) then
+        error stop ' initialization with'// &
+            ' logical(int8) failed to set the right values.'
+    else
+        write (*, *) 'Initialization with logical(int8) succeeded.'
+    end if
+    set1 = set0
+    if (set1 == set0) &
+        write (*, *) 'Initialization by assignment succeeded'
+    logical2 = set1
+    if (all(logical2)) then
+        write (*, *) 'Initialization of logical(int32) succeeded.'
+    end if
 end program demo_assignment

test/example/bitsets/demo_bitsets_bit_count.f90

@@ -1,15 +1,15 @@
 program demo_bit_count
-use stdlib_bitsets
-character(*), parameter :: &
-bits_0 = '0000000000000000000'
-type(bitset_64) :: set0
-call set0 % from_string( bits_0 )
-if ( set0 % bit_count() == 0 ) then
-write(*,*) "FROM_STRING interpreted " // &
-"BITS_0's value properly."
-end if
-call set0 % set(5)
-if ( set0 % bit_count() == 1 ) then
-write(*,*) "BIT_COUNT interpreted SET0's value properly."
-end if
+    use stdlib_bitsets
+    character(*), parameter :: &
+        bits_0 = '0000000000000000000'
+    type(bitset_64) :: set0
+    call set0%from_string(bits_0)
+    if (set0%bit_count() == 0) then
+        write (*, *) "FROM_STRING interpreted "// &
+            "BITS_0's value properly."
+    end if
+    call set0%set(5)
+    if (set0%bit_count() == 1) then
+        write (*, *) "BIT_COUNT interpreted SET0's value properly."
+    end if
 end program demo_bit_count

test/example/bitsets/demo_bitsets_bits.f90

@@ -1,11 +1,11 @@
 program demo_bits
-use stdlib_bitsets
-character(*), parameter :: &
-bits_0 = '0000000000000000000'
-type(bitset_64) :: set0
-call set0 % from_string( bits_0 )
-if ( set0 % bits() == 19 ) then
-write(*,*) "FROM_STRING interpreted " // &
-"BITS_0's size properly."
-end if
+    use stdlib_bitsets
+    character(*), parameter :: &
+        bits_0 = '0000000000000000000'
+    type(bitset_64) :: set0
+    call set0%from_string(bits_0)
+    if (set0%bits() == 19) then
+        write (*, *) "FROM_STRING interpreted "// &
+            "BITS_0's size properly."
+    end if
 end program demo_bits

test/example/bitsets/demo_bitsets_clear.f90

@@ -1,11 +1,11 @@
 program demo_clear
-use stdlib_bitsets
-type(bitset_large) :: set0
-call set0 % init(166)
-call set0 % not()
-if ( set0 % all() ) write(*,*) 'SET0 is properly initialized.'
-call set0 % clear(165)
-if ( .not. set0 % test(165) ) write(*,*) 'Bit 165 is cleared.'
-call set0 % clear(0,164)
-if ( set0 % none() ) write(*,*) 'All bits are cleared.'
+    use stdlib_bitsets
+    type(bitset_large) :: set0
+    call set0%init(166)
+    call set0%not()
+    if (set0%all()) write (*, *) 'SET0 is properly initialized.'
+    call set0%clear(165)
+    if (.not. set0%test(165)) write (*, *) 'Bit 165 is cleared.'
+    call set0%clear(0, 164)
+    if (set0%none()) write (*, *) 'All bits are cleared.'
 end program demo_clear

test/example/bitsets/demo_bitsets_equality.f90

@@ -1,16 +1,16 @@
 program demo_equality
-use stdlib_bitsets
-type(bitset_64) :: set0, set1, set2
-call set0 % init( 33 )
-call set1 % init( 33 )
-call set2 % init( 33 )
-call set1 % set( 0 )
-call set2 % set( 32 )
-if ( set0 == set0 .and. set1 == set1 .and. set2 == set2 .and. &
-.not. set0 == set1 .and. .not. set0 == set2 .and. .not.   &
-set1 == set2 ) then
-write(*,*) 'Passed 64 bit equality tests.'
-else
-error stop 'Failed 64 bit equality tests.'
-end if
+    use stdlib_bitsets
+    type(bitset_64) :: set0, set1, set2
+    call set0%init(33)
+    call set1%init(33)
+    call set2%init(33)
+    call set1%set(0)
+    call set2%set(32)
+    if (set0 == set0 .and. set1 == set1 .and. set2 == set2 .and. &
+        .not. set0 == set1 .and. .not. set0 == set2 .and. .not. &
+        set1 == set2) then
+        write (*, *) 'Passed 64 bit equality tests.'
+    else
+        error stop 'Failed 64 bit equality tests.'
+    end if
 end program demo_equality

test/example/bitsets/demo_bitsets_extract.f90

@@ -1,10 +1,10 @@
 program demo_extract
-use stdlib_bitsets
-type(bitset_large) :: set0, set1
-call set0 % init(166)
-call set0 % set(100,150)
-call extract( set1, set0, 100, 150)
-if ( set1 % bits() == 51 ) &
-write(*,*) 'SET1 has the proper size.'
-if ( set1 % all() ) write(*,*) 'SET1 has the proper values.'
+    use stdlib_bitsets
+    type(bitset_large) :: set0, set1
+    call set0%init(166)
+    call set0%set(100, 150)
+    call extract(set1, set0, 100, 150)
+    if (set1%bits() == 51) &
+        write (*, *) 'SET1 has the proper size.'
+    if (set1%all()) write (*, *) 'SET1 has the proper values.'
 end program demo_extract

test/example/bitsets/demo_bitsets_flip.f90

@@ -1,10 +1,10 @@
 program demo_flip
-use stdlib_bitsets
-type(bitset_large) :: set0
-call set0 % init(166)
-if ( set0 % none() ) write(*,*) 'SET0 is properly initialized.'
-call set0 % flip(165)
-if ( set0 % test(165) ) write(*,*) 'Bit 165 is flipped.'
-call set0 % flip(0,164)
-if ( set0 % all() ) write(*,*) 'All bits are flipped.'
+    use stdlib_bitsets
+    type(bitset_large) :: set0
+    call set0%init(166)
+    if (set0%none()) write (*, *) 'SET0 is properly initialized.'
+    call set0%flip(165)
+    if (set0%test(165)) write (*, *) 'Bit 165 is flipped.'
+    call set0%flip(0, 164)
+    if (set0%all()) write (*, *) 'All bits are flipped.'
 end program demo_flip