Fortran-lang Learn

https://fortran-lang.org/learn/
Admin
Fortran-lang Learn is a comprehensive learning resource offering tutorials, best practices, and...
Tokens:484,697
Snippets:2,946
Trust Score:9.6
Update:1 day ago
Show doc for...
Tokens:
Raw
### Output of meson setup build

Source: https://fortran-lang.org/learn/building_programs/build_tools/

Example output from running 'meson setup build' for the my_proj project. It shows the meson version, source and build directories, project name and version, Fortran compiler details, host machine information, and the location of ninja.

```text
The Meson build system
Version: 0.53.2
Source dir: /home/awvwgk/Examples
Build dir: /home/awvwgk/Examples/build
Build type: native build
Project name: my_proj
Project version: undefined
Fortran compiler for the host machine: gfortran (gcc 9.2.1 "GNU Fortran (Arch Linux 9.2.1+20200130-2) 9.2.1 20200130")
Fortran linker for the host machine: gfortran ld.bfd 2.34
Host machine cpu family: x86_64
Host machine cpu: x86_64
Build targets in project: 1

Found ninja-1.10.0 at /usr/bin/ninja
```

--------------------------------

### FPM build, run, and install commands

Source: https://fortran-lang.org/learn/building_programs/build_tools/

Common FPM commands: build, run, install (default location ~/local/bin), and install to a custom prefix.

```bash
fpm build
```

```bash
fpm run
```

```bash
fpm install
```

```bash
fpm install --prefix /a/path/to/custom/location
```

--------------------------------

### leadz(3) example - sample program

Source: https://fortran-lang.org/learn/intrinsics/bit/

Sample program demonstrating leadz for various integer values, printing the number of leading zero bits and the bit representation. Note that for two's-complement platforms, negative non-zero values start with a 1 and positive values with 0.

```fortran
program demo_leadz
implicit none
integer :: value, i
character(len=80) :: f

  ! make a format statement for writing a value as a bit string
  write(f,'("(b",i0,".",i0,")")')bit_size(value),bit_size(value)

  ! show output for various integer values
  value=0
  do i=-150, 150, 50
     value=i
     write (*,'("LEADING ZERO BITS=",i3)',advance='no') leadz(value)
     write (*,'(" OF VALUE ")',advance='no')
     write(*,f,advance='no') value
     write(*,'(*(1x,g0))') "AKA",value
  enddo
  ! Notes:
  ! for two's-complements programming environments a negative non-zero
  ! integer value will always start with a 1 and a positive value with 0
  ! as the first bit is the sign bit. Such platforms are very common.
end program demo_leadz
```

--------------------------------

### c_sizeof example output

Source: https://fortran-lang.org/learn/intrinsics/cfi/

Expected output from the example program.

```text
    T
```

--------------------------------

### Install FPM on Linux/WSL2

Source: https://fortran-lang.org/learn/building_programs/build_tools/

Clones the FPM repository and runs the install script. Installs FPM to ~/.local/bin/fpm.

```bash
git clone https://github.com/fortran-lang/fpm
cd fpm
./install.sh 
```

--------------------------------

### asin example: sine ratio

Source: https://fortran-lang.org/learn/intrinsics/math/

Shows the sine ratio used in the example.

```fortran
 sin(theta) = 1.25 miles/50 miles (opposite/hypotenuse)
```

--------------------------------

### cpu_time(3) Example Output

Source: https://fortran-lang.org/learn/intrinsics/system/

Example output from the sample program. The precision and values are system-dependent.

```text
   Processor Time =  0.000 seconds.
   Processor Time = .4000030E-05 seconds.
   Processor Time = .2000000000000265E-05 seconds.
```

--------------------------------

### inquire example with output

Source: https://fortran-lang.org/learn/f95_features/operations_on_external_files/

Example of inquiring about unit 2's properties, followed by the resulting output. Assumes no intervening read or write operations.

```fortran
logical            :: ex, op
character(len=11)  :: nam, acc, seq, frm
integer            :: irec, nr
inquire (unit=2, exist=ex, opened=op, name=nam, access=acc, sequential=seq, &
         form=frm, recl=irec, nextrec=nr)
```

```text
ex      .true.
op      .true.
nam      cities
acc      direct
seq      no
frm      unformatted
irec     100
nr       1
```

--------------------------------

### index(3) example program and expected output

Source: https://fortran-lang.org/learn/intrinsics/character/

Example program demonstrating index(3) with leftmost search, rightmost search using back=.true., and case sensitivity. The expected output is 'T T T'.

```fortran
program demo_index
implicit none
character(len=*),parameter :: str=&
   'Search this string for this expression'
   !1234567890123456789012345678901234567890
   write(*,*)&
      index(str,'this').eq.8,              &
      ! return value is counted from the left end even if BACK=.TRUE.
      index(str,'this',back=.true.).eq.24, &
      ! INDEX is case-sensitive
      index(str,'This').eq.0
end program demo_index
```

```text
   T T T
```

--------------------------------

### get_command example output

Source: https://fortran-lang.org/learn/intrinsics/system/

Example output from running the sample program, showing how shell expansion removes whitespace and how quoting preserves special characters.

```text
     # note that shell expansion removes some of the whitespace
     # without quotes
     ./test_get_command  arguments    on command   line to   echo

     OUTPUT:./test_get_command arguments on command line to echo

     # using the bash shell with single quotes
     ./test_get_command  'arguments  *><`~[]!{}"?\'| '

     OUTPUT:./test_get_command arguments  *><`~[]!{}"'|

```

--------------------------------

### Setup wtype object with initialize and setup_wtype

Source: https://fortran-lang.org/learn/oop_features_in_fortran/object_oriented_programming_techniques/

Example program that sets up a `wtype` object using `initialize` objects and the `setup_wtype` procedure. It uses an associate block to compute a matrix and then calls `setup_wtype` twice with different `initialize` objects.

```fortran
use mod_wtype
type(initialize) :: c_nz, c_w
type(wtype) :: my_wtype
integer :: i, j
integer :: ndim

ndim = ...

associate ( my_data => [ ((real (max(0, min(i-j+2, j-i+2))), j=1, ndim), i=1, ndim) ] )
  c_nz = initialize("nonzeros", count(my_data /= 0))
  c_w = initialize("w", my_data, [ ndim, ndim ] )
end associate

call setup_wtype(my_wtype, c_nz)
call setup_wtype(my_wtype, c_w)
```

--------------------------------

### Sample project structure

Source: https://fortran-lang.org/learn/building_programs/build_tools/

Directory layout generated by 'fpm new first_steps', showing the main program, module, and test files.

```text
├── README.md
├── app
│   └── main.f90
├── fpm.toml
├── src
│   └── first_steps.f90
└── test
    └── check.f90
```

--------------------------------

### random_number example program

Source: https://fortran-lang.org/learn/intrinsics/math/

Sample program demonstrating random_number to generate a large number of random integers in a range and count their frequencies. It uses random_seed to get the seed and shows a method to map a uniform real to an integer. The output shows roughly equal counts for each integer.

```fortran
program demo_random_number
use, intrinsic :: iso_fortran_env, only : dp=>real64
implicit none
integer, allocatable :: seed(:)
integer              :: n
integer              :: first,last
integer              :: i
integer              :: rand_int
integer,allocatable  :: count(:)
real(kind=dp)        :: rand_val
   call random_seed(size = n)
   allocate(seed(n))
   call random_seed(get=seed)
   first=1
   last=10
   allocate(count(last-first+1))
   ! To have a discrete uniform distribution on the integers
   ! [first, first+1, ..., last-1, last] carve the continuous
   ! distribution up into last+1-first equal sized chunks,
   ! mapping each chunk to an integer.
   !
   ! One way is:
   !   call random_number(rand_val)
   ! choose one from last-first+1 integers
   !   rand_int = first + FLOOR((last+1-first)*rand_val)
      count=0
      ! generate a lot of random integers from 1 to 10 and count them.
      ! with a large number of values you should get about the same
      ! number of each value
      do i=1,100000000
         call random_number(rand_val)
         rand_int=first+floor((last+1-first)*rand_val)
         if(rand_int.ge.first.and.rand_int.le.last)then
            count(rand_int)=count(rand_int)+1
         else
            write(*,*)rand_int,' is out of range'
         endif
      enddo
      write(*,'(i0,1x,i0)')(i,count(i),i=1,size(count))
end program demo_random_number

```

```text
   1 10003588
   2 10000104
   3 10000169
   4 9997996
   5 9995349
   6 10001304
   7 10001909
   8 9999133
   9 10000252
   10 10000196

```

--------------------------------

### Sample program using log

Source: https://fortran-lang.org/learn/intrinsics/math/

Example program demonstrating log with real and complex arguments, and its output.

```fortran
program demo_log
implicit none
  real(kind(0.0d0)) :: x = 2.71828182845904518d0
  complex :: z = (1.0, 2.0)
  write(*,*)x, log(x)    ! will yield (approximately) 1
  write(*,*)z, log(z)
end program demo_log

```

```text
      2.7182818284590451        1.0000000000000000
   (1.00000000,2.00000000) (0.804718971,1.10714877)

```

--------------------------------

### Sample output from compiler_options() program

Source: https://fortran-lang.org/learn/intrinsics/compiler/

Example output from the sample program, showing the compiler version and options for GCC, nvfortran, and Intel Fortran. The output is compiler-specific and demonstrates the format of the returned string.

```text
This file was compiled by GCC version 10.3.0 using
the options -I build/gfortran_2A42023B310FA28D
-mtune=generic -march=x86-64 -auxbase-strip
build/gfortran_2A42023B310FA28D/compiler_options/app_main.f90.o
-g -Wall -Wextra -Wimplicit-interface -fPIC -fmax-errors=1
-fcheck=bounds -fcheck=array-temps -fbacktrace
-fcoarray=single -J build/gfortran_2A42023B310FA28D
-fpre-include=/usr/include/finclude/math-vector-fortran.h

This file was compiled by nvfortran 21.5-0 LLVM
using the options app/main.f90 -c -Minform=inform
-Mbackslash -Mbounds -Mchkptr -Mchkstk -traceback -module
build/nvfortran_78229DCE997517A4 -Ibuild/nvfortran_78229DCE997517A4 -o
build/nvfortran_78229DCE997517A4/compiler_options/app_main.f90.o

This file was compiled by Intel(R) Fortran Intel(R) 64 Compiler Classic
for applications running on Intel(R) 64, Version 2021.3.0 Build
20210609_000000 using the options -Ibuild/ifort_5C58216731706F11
-c -warn all -check all -error-limit 1 -O0 -g -assume
byterecl -traceback -module build/ifort_5C58216731706F11 -o
build/ifort_5C58216731706F11/compiler_options/app_main.f90.o
```

--------------------------------

### Install gfortran on Debian-based systems (sudo apt install gfortran)

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Installs the default gfortran package on Debian, Ubuntu, Mint, and similar distributions. Run after confirming gfortran is not installed.

```bash
sudo apt install gfortran
```

--------------------------------

### get_command example program

Source: https://fortran-lang.org/learn/intrinsics/system/

Sample program that retrieves the command line length, allocates a string, and prints the command line. Demonstrates the use of get_command with length and command arguments.

```fortran
program demo_get_command
implicit none
integer                      :: command_line_length
character(len=:),allocatable :: command_line
   ! get command line length
   call get_command(length=command_line_length)
   ! allocate string big enough to hold command line
   allocate(character(len=command_line_length) :: command_line)
   ! get command line as a string
   call get_command(command=command_line)
   ! trim leading spaces just in case
   command_line=adjustl(command_line)
   write(*,'("OUTPUT:",a)')command_line
end program demo_get_command

```

--------------------------------

### Check if gfortran is installed (which gfortran)

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Run this command to check whether gfortran is already installed. If nothing is returned, gfortran is not installed.

```bash
which gfortran
```

--------------------------------

### dprod example program - demo_dprod

Source: https://fortran-lang.org/learn/intrinsics/numeric/

Sample program demonstrating dprod usage: basic call, comparison with x*y and dble(x)*dble(y), a test for expected result, and elemental usage with arrays.

```fortran
program demo_dprod
implicit none
integer,parameter :: dp=kind(0.0d0)
real :: x = 5.2
real :: y = 2.3
doubleprecision :: xx
real(kind=dp)   :: dd

   print *,'algebraically 5.2 x 2.3 is exactly 11.96'
   print *,'as floating point values results may differ slightly:'
   ! basic usage
   dd = dprod(x,y)
   print *, 'compare dprod(xy)=',dd, &
   & 'to x*y=',x*y, &
   & 'to dble(x)*dble(y)=',dble(x)*dble(y)

   print *,'test if an expected result is produced'
   xx=-6.0d0
   write(*,*)DPROD(-3.0, 2.0),xx
   write(*,*)merge('PASSED','FAILED',DPROD(-3.0, 2.0) == xx)

   print *,'elemental'
   print *, dprod( [2.3,3.4,4.5], 10.0 )
   print *, dprod( [2.3,3.4,4.5], [9.8,7.6,5.4] )

end program demo_dprod

```

```text
 >  algebraically 5.2 x 2.3 is exactly 11.96
 >  as floating point values results may differ slightly:
 >  compare dprod(xy)=   11.9599993133545      to x*y=   11.96000
 >  to dble(x)*dble(y)=   11.9599993133545
 >  test if an expected result is produced
 >   -6.00000000000000       -6.00000000000000
 >  PASSED
 >  elemental
 >    22.9999995231628     34.0000009536743     45.0000000000000
 >    22.5399999713898     25.8400004005432     24.3000004291534

```

--------------------------------

### Example build output with make

Source: https://fortran-lang.org/learn/building_programs/project_make/

This is the expected output when running make with the provided Makefile. It shows the sequence of commands: generating dependency files, compiling object files, creating the static library, and linking test executables.

```text
./gen-deps.awk src/csv_utilities.f90 > src/csv_utilities.f90.d
./gen-deps.awk src/csv_parameters.f90 > src/csv_parameters.f90.d
./gen-deps.awk src/csv_module.F90 > src/csv_module.F90.d
./gen-deps.awk src/csv_kinds.f90 > src/csv_kinds.f90.d
gfortran -c -o src/csv_kinds.f90.o src/csv_kinds.f90
gfortran -c -o src/csv_parameters.f90.o src/csv_parameters.f90
gfortran -c -o src/csv_utilities.f90.o src/csv_utilities.f90
gfortran -c -o src/csv_module.F90.o src/csv_module.F90
ar rcs libcsv.a src/csv_kinds.f90.o src/csv_module.F90.o src/csv_parameters.f90.o src/csv_utilities.f90.o
./gen-deps.awk src/tests/csv_read_test.f90 > src/tests/csv_read_test.f90.d
gfortran -c -o src/tests/csv_read_test.f90.o src/tests/csv_read_test.f90
gfortran -o src/tests/csv_read_test.exe src/tests/csv_read_test.f90.o libcsv.a
./gen-deps.awk src/tests/csv_test.f90 > src/tests/csv_test.f90.d
gfortran -c -o src/tests/csv_test.f90.o src/tests/csv_test.f90
gfortran -o src/tests/csv_test.exe src/tests/csv_test.f90.o libcsv.a
./gen-deps.awk src/tests/csv_write_test.f90 > src/tests/csv_write_test.f90.d
gfortran -c -o src/tests/csv_write_test.f90.o src/tests/csv_write_test.f90
gfortran -o src/tests/csv_write_test.exe src/tests/csv_write_test.f90.o libcsv.a

```

--------------------------------

### c_funloc example program

Source: https://fortran-lang.org/learn/intrinsics/cfi/

Sample program demonstrating c_funloc with a module and a main program.

```fortran
! program demo_c_funloc and module
module x
use iso_c_binding
implicit none
contains
subroutine sub(a) bind(c)
real(c_float) :: a
   a = sqrt(a)+5.0
end subroutine sub
end module x
!
program demo_c_funloc
use iso_c_binding
use x
implicit none
interface
   subroutine my_routine(p) bind(c,name='myC_func')
     import :: c_funptr
     type(c_funptr), intent(in) :: p
   end subroutine
end interface
   call my_routine(c_funloc(sub))
!
end program demo_c_funloc
```

--------------------------------

### storage_size(3) - Example program

Source: https://fortran-lang.org/learn/intrinsics/bit/

Sample program demonstrating storage_size for default integer, real, logical, complex, and an integer array. The output shows the storage sizes in bits.

```fortran
program demo_storage_size
implicit none

   ! a default real, integer, and logical are the same storage size
   write(*,*)'size of integer       ',storage_size(0)
   write(*,*)'size of real          ',storage_size(0.0)
   write(*,*)'size of logical       ',storage_size(.true.)
   write(*,*)'size of complex       ',storage_size((0.0,0.0))

   ! note the size of an element of the array, not the storage size of
   ! the entire array is returned for array arguments
   write(*,*)'size of integer array ',storage_size([0,1,2,3,4,5,6,7,8,9])

end program demo_storage_size
```

```text
    size of integer                 32
    size of real                    32
    size of logical                 32
    size of complex                 64
    size of integer array           32
```

--------------------------------

### co_sum example output

Source: https://fortran-lang.org/learn/intrinsics/parallel/

Example output from the co_sum sample program.

```text
    The sum is            1
```

--------------------------------

### min(3) sample program and output

Source: https://fortran-lang.org/learn/intrinsics/numeric/

Sample program demonstrating the min function with real arguments, followed by its output.

```fortran
program demo_min
implicit none
    write(*,*)min(10.0,11.0,30.0,-100.0)
end program demo_min
```

```text
      -100.0000000
```

--------------------------------

### floor(3) example program: demo_floor

Source: https://fortran-lang.org/learn/intrinsics/numeric/

Sample program demonstrating floor with positive, negative, and array arguments, including the effect of small deviations from whole numbers.

```fortran
program demo_floor
implicit none
real :: x = 63.29
real :: y = -63.59
    print *, x, floor(x)
    print *, y, floor(y)
   ! elemental
   print *,floor([ &
   &  -2.7,  -2.5, -2.2, -2.0, -1.5, -1.0, -0.5, &
   &  0.0,   &
   &  +0.5,  +1.0, +1.5, +2.0, +2.2, +2.5, +2.7  ])

   ! note even a small deviation from the whole number changes the result
   print *,      [2.0,2.0-epsilon(0.0),2.0-2*epsilon(0.0)]
   print *,floor([2.0,2.0-epsilon(0.0),2.0-2*epsilon(0.0)])

   ! A=Nan, Infinity or  <huge(0_KIND)-1 < A > huge(0_KIND) is undefined
end program demo_floor

```

--------------------------------

### Simply expanded variables example

Source: https://fortran-lang.org/learn/building_programs/build_tools/

Example of simply expanded variables in a Makefile. The include_dirs variable is defined with := and then appended with +=, and FFLAGS is defined with :=. This achieves the same result as the recursive example but with immediate expansion.

```makefile
all:
	echo $(FFLAGS)

include_dirs := -I./include
include_dirs += -I/opt/some_dep/include
FFLAGS := $(include_dirs) -O

```

--------------------------------

### Install gfortran on RPM-based systems (sudo yum install gcc-gfortran)

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Installs gfortran using the yum package manager on RPM-based distributions such as Red Hat Enterprise Linux, CentOS, Fedora, and openSUSE.

```bash
sudo yum install gcc-gfortran
```

--------------------------------

### Main program example

Source: https://fortran-lang.org/learn/f95_features/program_units_and_procedures/

A complete Fortran main program that prints 'Hello world!'. This is the simplest form of an executable program.

```fortran
program test
  print*,'Hello world!'
end program test
```

--------------------------------

### Install gfortran on RPM-based systems with dnf (sudo dnf install gcc-gfortran)

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Installs gfortran using dnf, the default package manager since Fedora 22 and Red Hat Enterprise Linux 8.

```bash
sudo dnf install gcc-gfortran
```

--------------------------------

### Install a specific gfortran version on Debian-based systems (sudo apt install gfortran-8)

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Installs a specific gfortran version by appending the version number to the package name. On Ubuntu 22.04, versions up to 10 are available.

```bash
sudo apt install gfortran-8
```

--------------------------------

### Sample program output for epsilon(3)

Source: https://fortran-lang.org/learn/intrinsics/model/

Output from the sample program, showing epsilon values for real32 and real64, and the results of comparisons with epsilon.

```text
  1.1920929E-07
  1.1920929E-07
  1.1920929E-07
  2.220446049250313E-016
 F
 F
 T
 T
  2.220446049250313E-016
```

--------------------------------

### Install gfortran on OpenBSD

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Installs the g95 package on OpenBSD. Note: the GFortran executable is named egfortran.

```bash
pkg_add g95
```

--------------------------------

### minval example program

Source: https://fortran-lang.org/learn/intrinsics/array/

A complete Fortran program demonstrating minval with various arguments: whole array, along dimensions, with masks, and zero-sized arrays.

```fortran
program demo_minval
implicit none
integer :: i
character(len=*),parameter :: g='(3x,*(g0,1x))'

integer,save :: ints(3,5)= reshape([&
       1,  -2,   3,   4,   5,  &
      10,  20, -30,  40,  50,  &
      11,  22,  33, -44,  55  &
],shape(ints),order=[2,1])

integer,save :: box(3,5,2)

   box(:,:,1)=ints
   box(:,:,2)=-ints

   write(*,*)'Given the array'
   write(*,'(1x,*(g4.4,1x))') &
   & (ints(i,:),new_line('a'),i=1,size(ints,dim=1))

   write(*,*)'What is the smallest element in the array?'
   write(*,g) minval(ints),'at <',minloc(ints),'>'

   write(*,*)'What is the smallest element in each column?'
   write(*,g) minval(ints,dim=1)

   write(*,*)'What is the smallest element in each row?'
   write(*,g) minval(ints,dim=2)

   ! notice the shape of the output has less columns
   ! than the input in this case
   write(*,*)'What is the smallest element in each column,'
   write(*,*)'considering only those elements that are'
   write(*,*)'greater than zero?'
   write(*,g) minval(ints, dim=1, mask = ints > 0)

   write(*,*)&
   & 'if everything is false a zero-sized array is NOT returned'
   write(*,*) minval(ints, dim=1, mask = .false.)
   write(*,*)'even for a zero-sized input'
   write(*,g) minval([integer ::], dim=1, mask = .false.)

   write(*,*)'a scalar answer for everything false is huge()'
   write(*,g) minval(ints, mask = .false.)
   write(*,g) minval([integer ::], mask = .false.)

   write(*,*)'some calls with three dimensions'
   write(*,g) minval(box, mask = .true. )
   write(*,g) minval(box, dim=1, mask = .true. )

   write(*,g) minval(box, dim=2, mask = .true. )
   write(*,g) 'shape of answer is ', &
   & shape(minval(box, dim=2, mask = .true. ))

end program demo_minval

```

--------------------------------

### Install a gcc version with MacPorts

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Installs a specific gcc version (e.g., gcc10) using MacPorts.

```bash
sudo port install gcc10
```

--------------------------------

### shiftl(3) - Sample Program: demo_shiftl

Source: https://fortran-lang.org/learn/intrinsics/bit/

Complete Fortran program demonstrating shiftl with basic usage, elemental behavior on arrays, and printing results in binary and decimal. Uses iso_fortran_env for integer kinds.

```fortran
program demo_shiftl
use,intrinsic :: iso_fortran_env, only : int8, int16, int32, int64
implicit none
integer             :: shift
integer(kind=int32) :: oval
integer(kind=int32) :: ival
integer(kind=int32),allocatable :: ivals(:)
integer             :: i

  print *, ' basic usage'
  ival=100
  write(*,*)ival, shiftl(ival,3)

 ! elemental (input values may be conformant arrays)
  print *, ' elemental'

 ! loop through some ivalues
   shift=9
   ivals=[ &
   & int(b"01010101010101010101010101010101"), &
   & int(b"10101010101010101010101010101010"), &
   & int(b"11111111111111111111111111111111") ]

   write(*,'(/,"SHIFT =  ",i0)') shift
   do i=1,size(ivals)
      ! print initial value as binary and decimal
      write(*,'(  "I =      ",b32.32," == ",i0)') ivals(i),ivals(i)
      ! print shifted value as binary and decimal
      oval=shiftl(ivals(i),shift)
      write(*,'(  "RESULT = ",b32.32," == ",i0)') oval,oval
   enddo

  ! more about elemental
   ELEM : block
   integer(kind=int8)  :: arr(2,2)=reshape([2,4,8,16],[2,2])
   write(*,*)"characteristics of the result are the same as input"
   write(*,'(*(g0,1x))') &
     & "kind=",kind(shiftl(arr,3)), "shape=",shape(shiftl(arr,3)), &
     & "size=",size(shiftl(arr,3)) !, "rank=",rank(shiftl(arr,3))
   endblock ELEM

end program demo_shiftl
```

--------------------------------

### Check installed gfortran version (gfortran --version)

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Displays the version of the installed gfortran compiler.

```bash
gfortran --version
```

--------------------------------

### dshiftl sample program

Source: https://fortran-lang.org/learn/intrinsics/bit/

A complete Fortran program demonstrating dshiftl with various inputs and printing results in binary.

```fortran
program demo_dshiftl
use,intrinsic :: iso_fortran_env, only : int8, int16, int32, int64
implicit none
integer(kind=int32) :: i, j
integer             :: shift

  ! basic usage
   write(*,*) dshiftl (1, 2**30, 2) ! int32 values on little-endian => 5

  ! print some simple calls as binary to better visual the results
   i=-1
   j=0
   shift=5
   call printit()

   ! the leftmost SHIFT bits of J are copied to the rightmost result bits
   j=int(b"11111000000000000000000000000000")
   ! and the other bits are the rightmost bits of I
   i=int(b"00000000000000000000000000000000")
   call printit()

   j=int(b"11111000000000000000000000000000")
   i=int(b"00000111111111111111111111111111")
   ! result should be all 1s
   call printit()

contains
subroutine printit()
   ! print i,j,shift and then i,j, and the result as binary values
    write(*,'(*(g0))')'I=',i,' J=',j,' SHIFT=',shift
    write(*,'(b32.32)') i,j, dshiftl (i, j, shift)
end subroutine printit

end program demo_dshiftl

```

--------------------------------

### Install gfortran via Homebrew on macOS

Source: https://fortran-lang.org/learn/os_setup/install_gfortran/

Installs the GNU Compiler Collection (including gfortran) using Homebrew.

```bash
brew install gcc
```

--------------------------------

### set_exponent example program

Source: https://fortran-lang.org/learn/intrinsics/model/

Sample program demonstrating set_exponent. It prints the result of set_exponent(x, i) and compares it with fraction(x) * radix(x)**i. The expected output is shown.

```fortran
program demo_setexp
implicit none
real :: x = 178.1387e-4
integer :: i = 17
   print *, set_exponent(x, i), fraction(x) * radix(x)**i
end program demo_setexp
```

```text
      74716.7891       74716.7891
```

--------------------------------

### selected_real_kind example output

Source: https://fortran-lang.org/learn/intrinsics/type/

Example output from the sample program showing precision and range values for the selected kinds.

```text
  >            6          37
  >           15         307
  >           18        4931
```

--------------------------------

### close statement example with delete status

Source: https://fortran-lang.org/learn/f95_features/operations_on_external_files/

Example of closing unit 2 and deleting the file by specifying status='delete'.

```fortran
close (unit=2, iostat=ios, status="delete")
```

--------------------------------

### present(3) - Example Program and Output

Source: https://fortran-lang.org/learn/intrinsics/state/

Complete Fortran program demonstrating present(3) with an optional dummy argument. It shows how to test for presence, use the argument when present, and pass it to other procedures. The output shows the behavior for both present and absent cases.

```fortran
program demo_present
implicit none
integer :: answer
   ! argument to func() is not present
   answer=func()
   write(*,*) answer
   ! argument to func() is present
   answer=func(1492)
   write(*,*) answer
contains
!
integer function func(x)
! the optional characteristic on this definition allows this variable
! to not be specified on a call; and also allows it to subsequently
! be passed to PRESENT(3):
integer, intent(in), optional :: x
integer :: x_local
   !
   ! basic
   if(present(x))then
     ! if present, you can use x like any other variable.
     x_local=x
   else
     ! if not, you cannot define or reference x except to
     ! pass it as an optional parameter to another procedure
     ! or in a call to present(3f)
     x_local=0
   endif
   !
   func=x_local**2
   !
   ! passing the argument on to other procedures
   ! so something like this is a bad idea because x is used
   ! as the first argument to merge(3f) when it might not be
   ! present
   ! xlocal=merge(x,0,present(x)) ! NO!!
   !
   ! We can pass it to another procedure if another
   ! procedure declares the argument as optional as well,
   ! or we have tested that X is present
   call tattle('optional argument x',x)
   if(present(x))call not_optional(x)
end function
!
subroutine tattle(label,arg)
character(len=*),intent(in) :: label
integer,intent(in),optional :: arg
   if(present(arg))then
      write(*,*)label,' is present'
   else
      write(*,*)label,' is not present'
   endif
end subroutine tattle
!
subroutine not_optional(arg)
integer,intent(in) :: arg
   write(*,*)'already tested X is defined',arg
end subroutine not_optional
!
end program demo_present
```

```text
    optional argument x is not present
              0
    optional argument x is present
    already tested X is defined 1492
        2226064
```
Tokens:
Raw