5 |16 | -------------------------------------------------------------------------------- /exercises/06-type-extension-polypmorphism/object_type.f90: -------------------------------------------------------------------------------- 1 | module object_type 2 | 3 | implicit none 4 | public 5 | 6 | type, public :: object_t 7 | real :: rho = 1.0 ! density 8 | real :: x(3) = 0.0 ! position of centre of mass 9 | end type object_t 10 | 11 | type, extends(object_t), public :: sphere_t 12 | real :: a = 1.0 ! radius 13 | end type sphere_t 14 | 15 | end module object_type 16 | -------------------------------------------------------------------------------- /bin/boilerplate/index.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: lesson 3 | root: . # Is the only page that doesn't follow the pattern /:path/index.html 4 | permalink: index.html # Is the only page that doesn't follow the pattern /:path/index.html 5 | --- 6 | FIXME: home page introduction 7 | 8 | 9 | 10 | {% comment %} This is a comment in Liquid {% endcomment %} 11 | 12 | > ## Prerequisites 13 | > 14 | > FIXME 15 | {: .prereq} 16 | 17 | {% include links.md %} 18 | -------------------------------------------------------------------------------- /exercises/10-modules-again/example_module.f90: -------------------------------------------------------------------------------- 1 | module example_module 2 | 3 | implicit none 4 | public 5 | 6 | type, public :: example_t 7 | private 8 | integer :: data = 0 9 | end type example_t 10 | 11 | interface example_t 12 | module function example_int_t(ival) result(e) 13 | integer, intent(in) :: ival 14 | type (example_t) :: e 15 | end function example_int_t 16 | end interface example_t 17 | 18 | end module example_module 19 | -------------------------------------------------------------------------------- /exercises/08-generic-io-for-derived-types/date_program.f90: -------------------------------------------------------------------------------- 1 | program date_program 2 | 3 | use date_module 4 | implicit none 5 | 6 | type (my_type) :: date 7 | 8 | date%day = 21 9 | date%month = 4 10 | date%year = 2022 11 | 12 | ! Some valid date examples ... 13 | 14 | print *, "List directed date output: ", date 15 | ! print "(a,dt)", "Default dt format: ", date 16 | ! print "(a,dt(2,4,5))", "vlist dt format: ", date 17 | 18 | end program date_program 19 | -------------------------------------------------------------------------------- /CODE_OF_CONDUCT.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: "Contributor Code of Conduct" 4 | --- 5 | As contributors and maintainers of this project, 6 | we pledge to follow the [Carpentry Code of Conduct][coc]. 7 | 8 | Instances of abusive, harassing, or otherwise unacceptable behavior 9 | may be reported by following our [reporting guidelines][coc-reporting]. 10 | 11 | Participants are required to abide by the [ARCHER2 Training Code of Conduct][archer2-tcoc]. 12 | 13 | {% include links.md %} 14 | -------------------------------------------------------------------------------- /exercises/08-generic-io-for-derived-types/solutions/date_program.f90: -------------------------------------------------------------------------------- 1 | program date_program 2 | 3 | use date_module 4 | implicit none 5 | 6 | type (my_type) :: date 7 | 8 | date%day = 21 9 | date%month = 4 10 | date%year = 2022 11 | 12 | ! Some valid date examples ... 13 | 14 | print *, "List directed date output: ", date 15 | print "(a,dt)", "Default dt format: ", date 16 | print "(a,dt(2,4,5))", "vlist dt format: ", date 17 | 18 | end program date_program 19 | -------------------------------------------------------------------------------- /exercises/09-abstract-types/example1.f90: -------------------------------------------------------------------------------- 1 | program example1 2 | 3 | ! Write a file using the concrete class for formatted output. 4 | ! Compile with: ftn file_module.f90 example1.f90 5 | 6 | use file_module 7 | implicit none 8 | 9 | type (file_formatted_writer_t) :: f 10 | integer :: data(4) = [ 3.0, 5.0, 7.0, 9.0 ] 11 | integer :: ierr 12 | 13 | ! Open a file, say "file_formatted.dat" 14 | ! Write `data` to the file 15 | ! Close the file 16 | 17 | end program example1 18 | -------------------------------------------------------------------------------- /exercises/09-abstract-types/solutions/example1.f90: -------------------------------------------------------------------------------- 1 | program example1 2 | 3 | ! Write a file using the concrete class for formatted output. 4 | ! Compile with: ftn file_module.f90 example1.f90 5 | 6 | use file_module 7 | implicit none 8 | 9 | type (file_formatted_writer_t) :: f 10 | integer :: data(4) = [ 3.0, 5.0, 7.0, 9.0 ] 11 | integer :: ierr 12 | 13 | ierr = f%open("file_formatted.dat") 14 | ierr = f%write(data) 15 | ierr = f%close() 16 | 17 | end program example1 18 | -------------------------------------------------------------------------------- /exercises/01-arrays/problem1.f90: -------------------------------------------------------------------------------- 1 | program array_sections 2 | 3 | implicit none 4 | 5 | ! Given the following arrays ... 6 | 7 | integer :: a(10) = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] 8 | integer :: b(2, 3) = reshape( [1,2,3,4,5,6], shape = [2,3]) 9 | 10 | ! Write an array section to print ... 11 | 12 | ! a. elements 1, 2 and 7 of a 13 | 14 | ! b. all elements of a with odd index 15 | 16 | ! c. elements b(1, 1), b(2, 1), b(1, 3) and b(2, 3) 17 | 18 | end program array_sections 19 | -------------------------------------------------------------------------------- /exercises/02-arrays-as-arguments/example2.f90: -------------------------------------------------------------------------------- 1 | program example2 2 | 3 | implicit none 4 | 5 | real :: a(5) = [ 1.0, 2.0, 3.0, 4.0, 5.0 ] 6 | 7 | call my_array_operation(a(1:5:2)) 8 | print "(a,5(1x,f5.2))", "Final values ", a(1:5) 9 | 10 | contains 11 | 12 | subroutine my_array_operation(b) 13 | 14 | real, intent(inout) :: b(:) 15 | 16 | print *, "shape(b): ", shape(b) 17 | 18 | b(:) = 0.0 19 | 20 | end subroutine my_array_operation 21 | 22 | end program example2 23 | -------------------------------------------------------------------------------- /exercises/04-derived-types/example2.f90: -------------------------------------------------------------------------------- 1 | program example2 2 | 3 | use my_array_type 4 | implicit none 5 | 6 | type (my_array_t), target :: a 7 | type (my_array_t) :: b 8 | type (my_array_pointer_t) :: c 9 | 10 | b = my_array_allocate(3) 11 | a = b 12 | 13 | print *, "State of a ", a%nlen, allocated(a%values) 14 | 15 | c%nlen = a%nlen 16 | c%values => a%values 17 | 18 | print *, "State of c ", c%nlen, associated(c%values), c%values 19 | 20 | end program example2 21 | -------------------------------------------------------------------------------- /exercises/03-more-on-pointers/solutions/example2.f90: -------------------------------------------------------------------------------- 1 | program example2 2 | 3 | implicit none 4 | 5 | interface 6 | function array_size(a) result(isize) 7 | real, dimension(:), intent(in) :: a 8 | integer :: isize 9 | end function array_size 10 | end interface 11 | 12 | procedure (array_size), pointer :: f => array_size 13 | real :: a(13) 14 | 15 | print *, "size of a is: ", array_size(a) 16 | print *, "size of a is: ", f(a) 17 | 18 | end program example2 19 | -------------------------------------------------------------------------------- /exercises/03-more-on-pointers/solutions/example1.f90: -------------------------------------------------------------------------------- 1 | program example1 2 | 3 | implicit none 4 | 5 | integer, target :: a(10) 6 | integer, pointer :: p(:) 7 | integer :: i 8 | 9 | p => a(2:10:2) 10 | a = [ (i, i = 1, 10) ] 11 | 12 | ! print pointer lower bound lbound() 13 | print *, "Lower bound: ", lbound(p) ! => 1 14 | 15 | ! print pointer upper bound ubound() 16 | print *, "Upper bound: ", ubound(p) ! => 5 17 | 18 | ! check size and elements 19 | print *, "Size: ", size(p) ! => 5 20 | print *, "p(4) = ", p(4) ! => 8 21 | 22 | end program example1 23 | -------------------------------------------------------------------------------- /exercises/07-type-bound-procedures/object_type.f90: -------------------------------------------------------------------------------- 1 | module object_type 2 | 3 | implicit none 4 | public 5 | 6 | type, public :: object_t 7 | real :: rho = 1.0 ! density 8 | real :: x(3) = 0.0 ! position of centre of mass 9 | end type object_t 10 | 11 | type, extends(object_t), public :: sphere_t 12 | real :: a = 1.0 ! radius 13 | end type sphere_t 14 | 15 | type, extends(sphere_t), public :: charged_sphere_t 16 | real :: q = -1.0 ! charge 17 | end type charged_sphere_t 18 | 19 | contains 20 | 21 | end module object_type 22 | -------------------------------------------------------------------------------- /exercises/11-unlimited-polymorphic-entities/example1.f90: -------------------------------------------------------------------------------- 1 | program example1 2 | 3 | use iso_fortran_env 4 | implicit none 5 | 6 | real (real32), target :: r32 = 32.0 7 | real (real64), target :: r64 = 64.0 8 | real (real32), pointer :: p32 => null() 9 | real (real64), pointer :: p64 => null() 10 | 11 | class (*), pointer :: p => null() 12 | 13 | p32 => r32 14 | p32 => r64 15 | p => r32 16 | p => r64 17 | 18 | p32 = 0.0 19 | p = 0.0 20 | 21 | p32 => p 22 | 23 | print *, "Result ", p32, p64 24 | print *, "Result ", p 25 | 26 | end program example1 27 | -------------------------------------------------------------------------------- /_includes/workshop_calendar.html: -------------------------------------------------------------------------------- 1 | Add to your Google Calendar. 2 | -------------------------------------------------------------------------------- /exercises/04-derived-types/solutions/example2.f90: -------------------------------------------------------------------------------- 1 | program example2 2 | 3 | use my_array_type 4 | implicit none 5 | 6 | type (my_array_t), target :: a 7 | type (my_array_t) :: b 8 | type (my_array_pointer_t) :: c 9 | 10 | b = my_array_allocate(3) 11 | a = b 12 | 13 | print *, "State of a ", a%nlen, allocated(a%values) 14 | 15 | c%nlen = a%nlen 16 | c%values => a%values 17 | 18 | print *, "State of c ", c%nlen, associated(c%values), c%values 19 | 20 | call my_array_destroy(a) 21 | 22 | print *, "State of c ", c%nlen, associated(c%values), c%values 23 | 24 | end program example2 25 | -------------------------------------------------------------------------------- /exercises/10-modules-again/solutions/example2.f90: -------------------------------------------------------------------------------- 1 | program example1 2 | 3 | use file_module 4 | implicit none 5 | 6 | class (file_writer_t), pointer :: f => null() 7 | integer :: data(4) = [ 2, 4, 6, 8 ] 8 | integer :: ierr 9 | 10 | f => file_writer_from_string("formatted") 11 | 12 | ierr = f%open("data_formatted.dat") 13 | ierr = f%write(data) 14 | ierr = f%close() 15 | 16 | deallocate(f) 17 | 18 | f => file_writer_from_string("unformatted") 19 | 20 | ierr = f%open("data_unformatted.dat") 21 | ierr = f%write(data) 22 | ierr = f%close() 23 | 24 | deallocate(f) 25 | 26 | end program example1 27 | -------------------------------------------------------------------------------- /exercises/02-arrays-as-arguments/example1.f90: -------------------------------------------------------------------------------- 1 | program assumed_shape 2 | 3 | implicit none 4 | 5 | ! The program should print out the values 0.0, 1.0, ..., 3.0 6 | 7 | real :: a(0:3) 8 | 9 | call initialise(a) 10 | 11 | print *, "Values are: ", a(:) 12 | 13 | contains 14 | 15 | subroutine initialise(array) 16 | 17 | real, intent(inout) :: array(:) 18 | 19 | ! Initialise the values to the corresponding index 20 | 21 | integer :: i 22 | 23 | do i = lbound(array, dim = 1), ubound(array, dim = 1) 24 | array(i) = 1.0*i 25 | end do 26 | 27 | end subroutine initialise 28 | 29 | end program assumed_shape 30 | -------------------------------------------------------------------------------- /exercises/04-derived-types/my_semi_opaque_type.f90: -------------------------------------------------------------------------------- 1 | module my_semi_opaque_type 2 | 3 | ! An example dervided type 4 | 5 | implicit none 6 | public 7 | 8 | type, public :: my_semi_opaque_t 9 | private 10 | integer :: idata 11 | integer, public :: ndata 12 | end type my_semi_opaque_t 13 | 14 | contains 15 | 16 | function my_semi_opaque(idata, ndata) result(res) 17 | 18 | integer, intent(in) :: idata 19 | integer, intent(in) :: ndata 20 | type (my_semi_opaque_t) :: res 21 | 22 | res%idata = idata 23 | res%ndata = ndata 24 | 25 | end function my_semi_opaque 26 | 27 | end module my_semi_opaque_type 28 | -------------------------------------------------------------------------------- /exercises/05-interfaces-overloading/example3.f90: -------------------------------------------------------------------------------- 1 | program example3 2 | 3 | use my_vector_type 4 | implicit none 5 | 6 | type (my_vector_t) :: i = my_vector_t(1, 0, 0) 7 | type (my_vector_t) :: j = my_vector_t(0, 1, 0) 8 | type (my_vector_t) :: k = my_vector_t(0, 0, 1) 9 | 10 | ! scalar products 11 | ! i .dot. i should be 1 12 | ! i .dot. j should be 0 13 | 14 | ! vector products 15 | ! i .x. j should be k 16 | ! j .x. k should be i 17 | ! k .x. j should be -i 18 | 19 | ! scalar triple product 20 | ! i .dot. j .x. k should be 1 21 | 22 | ! vector triple product 23 | ! j .x. (i .x. j) should be (1, 0, 0) 24 | 25 | end program example3 26 | -------------------------------------------------------------------------------- /exercises/08-generic-io-for-derived-types/date_module.f90: -------------------------------------------------------------------------------- 1 | module date_module 2 | 3 | ! A module which defines a simple date type, and overrides the 4 | ! default formatted write. 5 | 6 | implicit none 7 | 8 | type :: my_type 9 | integer :: day = 0 10 | integer :: month = 0 11 | integer :: year = 0 12 | end type my_type 13 | 14 | ! Define some months, so we can produce formats like "12 Dec 2022" 15 | character (len = 3), dimension(12), parameter :: months = & 16 | [character (len = 3) :: "Jan", "Feb", "Mar", "Apr", "May", "Jun", & 17 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ] 18 | 19 | end module date_module 20 | -------------------------------------------------------------------------------- /exercises/11-unlimited-polymorphic-entities/key_value_program.f90: -------------------------------------------------------------------------------- 1 | program key_value_program 2 | 3 | ! Generate three key value pairs of different types. 4 | ! If the list is implemented they could be added to 5 | ! a list. 6 | 7 | use key_value_module 8 | implicit none 9 | 10 | type (key_value_t) :: kv1 = key_value_t() 11 | type (key_value_t) :: kv2 = key_value_t() 12 | type (key_value_t) :: kv3 = key_value_t() 13 | 14 | 15 | kv1 = key_value_t("kv1", 2) 16 | kv2 = key_value_t("kv2", 3.141) 17 | kv3 = key_value_t("kv3", "foo") 18 | 19 | call key_value_print(kv1) 20 | call key_value_print(kv2) 21 | call key_value_print(kv3) 22 | 23 | end program key_value_program 24 | -------------------------------------------------------------------------------- /exercises/05-interfaces-overloading/example1.f90: -------------------------------------------------------------------------------- 1 | program example1 2 | 3 | ! Exercise (see also my_array_type.f90) to 4 | ! 5 | ! 1. replace my_array_allocate(3) to a call with the overloaded 6 | ! my_array_t(3) 7 | ! 8 | ! 2. write an additional generic procedure to allow, e.g., 9 | ! a = my_array_t(nlen, iconstant) which allocates a%values(nlen) 10 | ! and initialises all values to scalar integer iconstant 11 | 12 | use my_array_type 13 | implicit none 14 | 15 | type (my_array_t) :: a 16 | 17 | a = my_array_allocate(3) 18 | 19 | print *, "State of a ", a%nlen, allocated(a%values), a%values(:) 20 | 21 | call my_array_destroy(a) 22 | 23 | end program example1 24 | -------------------------------------------------------------------------------- /setup.md: -------------------------------------------------------------------------------- 1 | --- 2 | layout: page 3 | title: Setup 4 | --- 5 | 6 | Please try to complete the following setup tasks ahead of the lesson. 7 | 8 | ## Create appropriate SAFE accounts 9 | 10 | Course attendees should have received instructions on how to set up an Archer SAFE account. 11 | Details are available in the [ARCHER2 documentation][archer2-quickstart]. 12 | 13 | This will allow you to obtain a machine account which will be used for the course. 14 | (If you already have a machine account, it is possible to use that, although you may not have access to the course queue reservation.) 15 | 16 | Any problems encountered will be addressed as the first part of the course. 17 | 18 | 19 | {% include links.md %} 20 | -------------------------------------------------------------------------------- /_includes/all_keypoints.html: -------------------------------------------------------------------------------- 1 | {% comment %} 2 | Display key points of all episodes for reference. 3 | {% endcomment %} 4 | 5 | {% include base_path.html %} 6 | 7 |Overview
6 | 7 |8 |14 | 15 |9 | Break: {{ page.break }} min 10 |11 |12 |13 |
Key Points
8 || 13 | {{ episode.title }} 14 | | 15 |
16 |
|
22 |
2 | Data Carpentry 3 | aims to help researchers get their work done 4 | in less time and with less pain 5 | by teaching them basic research computing skills. 6 | This hands-on workshop will cover basic concepts and tools, 7 | including program design, version control, data management, 8 | and task automation. 9 | Participants will be encouraged to help one another 10 | and to apply what they have learned to their own research problems. 11 |
12 |13 | 14 | For more information on what we teach and why, 15 | please see our paper 16 | "Best Practices for Scientific Computing". 17 | 18 |
19 | -------------------------------------------------------------------------------- /exercises/14-interoperability-with-c/solutions/c_struct_to_fortran.c: -------------------------------------------------------------------------------- 1 | #include2 | Software Carpentry 3 | aims to help researchers get their work done 4 | in less time and with less pain 5 | by teaching them basic research computing skills. 6 | This hands-on workshop will cover basic concepts and tools, 7 | including program design, version control, data management, 8 | and task automation. 9 | Participants will be encouraged to help one another 10 | and to apply what they have learned to their own research problems. 11 |
12 |13 | 14 | For more information on what we teach and why, 15 | please see our paper 16 | "Best Practices for Scientific Computing". 17 | 18 |
19 | -------------------------------------------------------------------------------- /_includes/workshop_footer.html: -------------------------------------------------------------------------------- 1 | {% comment %} 2 | Footer for a standard workshop. 3 | {% endcomment %} 4 | 27 | -------------------------------------------------------------------------------- /exercises/02-arrays-as-arguments/solutions/exercise1.f90: -------------------------------------------------------------------------------- 1 | program exercise1 2 | 3 | implicit none 4 | 5 | real, allocatable :: a(:) 6 | 7 | a = [ 1.0, 2.0, 3.0, 4.0, 5.0 ] 8 | print *, "Initial values ", a 9 | 10 | call my_array_operation(a) 11 | ! call my_array_operation(a(1:5:2)) 12 | ! a = alloc_arr() 13 | 14 | print *, "Final values ", a 15 | 16 | contains 17 | 18 | subroutine my_array_operation(b) 19 | 20 | real, allocatable, intent(out) :: b(:) 21 | 22 | if (.not. allocated(b)) then 23 | print *, "The argument b is unallocated" 24 | return 25 | end if 26 | 27 | print *, "shape(b): ", shape(b) 28 | 29 | b(:) = 0.0 30 | 31 | end subroutine my_array_operation 32 | 33 | function alloc_arr() result(arr) 34 | 35 | integer, allocatable :: arr(:) 36 | 37 | end function alloc_arr 38 | 39 | end program exercise1 40 | -------------------------------------------------------------------------------- /exercises/06-type-extension-polypmorphism/example2.f90: -------------------------------------------------------------------------------- 1 | program example2 2 | 3 | use object_type 4 | implicit none 5 | 6 | type (object_t), target :: obj = object_t() 7 | type (sphere_t), target :: s = sphere_t() 8 | type (charged_sphere_t), target :: cs 9 | 10 | class (object_t), pointer :: p => null() 11 | 12 | obj = object_t(rho = 1.0, x = [1.0, 2.0, 3.0]) 13 | s = sphere_t(object_t = obj, a = 2.5) 14 | cs = charged_sphere_t(sphere_t = s, q = -1.0) 15 | 16 | p => obj 17 | 18 | print *, "object density ", p%rho 19 | print *, "object position ", p%x(:) 20 | print *, "object radius ", p%a 21 | 22 | p => s 23 | 24 | print *, "sphere density ", p%rho 25 | print *, "sphere position ", p%x(:) 26 | print *, "sphere radius ", p%a 27 | 28 | p => cs 29 | print *, "sphere charge ", p%q 30 | 31 | end program example2 32 | -------------------------------------------------------------------------------- /exercises/05-interfaces-overloading/my_array_type.f90: -------------------------------------------------------------------------------- 1 | module my_array_type 2 | 3 | implicit none 4 | public 5 | 6 | type, public :: my_array_t 7 | integer :: nlen = 0 8 | real, allocatable :: values(:) 9 | end type my_array_t 10 | 11 | contains 12 | 13 | function my_array_allocate(nlen) result(a) 14 | 15 | integer, intent(in) :: nlen 16 | type (my_array_t) :: a 17 | integer :: i 18 | 19 | a%nlen = nlen 20 | a%values = [ (1.0*i, i = 1, nlen) ] 21 | 22 | end function my_array_allocate 23 | 24 | !---------------------------------------------------------------------------- 25 | 26 | subroutine my_array_destroy(a) 27 | 28 | type (my_array_t), intent(inout) :: a 29 | 30 | a%nlen = 0 31 | if (allocated(a%values)) deallocate(a%values) 32 | 33 | end subroutine my_array_destroy 34 | 35 | end module my_array_type 36 | -------------------------------------------------------------------------------- /_includes/lc/intro.html: -------------------------------------------------------------------------------- 1 |2 | Library Carpentry 3 | is made by people working in library- and information-related roles to help you: 4 |
5 |-
6 |
- automate repetitive, boring, error-prone tasks 7 |
- create, maintain and analyze sustainable and reusable data 8 |
- work effectively with IT and systems colleagues 9 |
- better understand the use of software in research 10 |
- and much more... 11 |
13 | 14 | Library Carpentry introduces you to the fundamentals of computing 15 | and provides you with a platform for further self-directed learning. 16 | For more information on what we teach and why, please see our paper 17 | "Library Carpentry: software skills training for library professionals". 18 | 19 |
20 | -------------------------------------------------------------------------------- /exercises/06-type-extension-polypmorphism/example1.f90: -------------------------------------------------------------------------------- 1 | program test1 2 | 3 | use object_type 4 | implicit none 5 | 6 | type (object_t) :: obj 7 | type (sphere_t) :: s 8 | real :: rho = 1.0 9 | real :: x(3) = [ 2.0, 3.0, 4.0 ] 10 | real :: radius = 1.5 11 | 12 | s = sphere_t(rho, x, radius) 13 | 14 | print *, "Sphere density ", s%object_t%rho 15 | print *, "Sphere density ", s%rho 16 | print *, "Sphere radius ", s%a 17 | 18 | s = sphere_t(a = radius, rho = rho , x = x) 19 | 20 | print *, "Sphere density ", s%object_t%rho 21 | print *, "Sphere density ", s%rho 22 | print *, "Sphere radius ", s%a 23 | 24 | obj = object_t(2.5, [1.0, 1.0, 1.0]) 25 | s = sphere_t(obj, radius) 26 | 27 | print *, "Sphere density ", s%rho 28 | print *, "Sphere position: ", s%x 29 | print *, "Sphere radius ", s%a 30 | 31 | end program test1 32 | -------------------------------------------------------------------------------- /exercises/06-type-extension-polypmorphism/solutions/example1.f90: -------------------------------------------------------------------------------- 1 | program test1 2 | 3 | use object_type 4 | implicit none 5 | 6 | type (object_t) :: obj 7 | type (sphere_t) :: s 8 | real :: rho = 1.0 9 | real :: x(3) = [ 2.0, 3.0, 4.0 ] 10 | real :: radius = 1.5 11 | 12 | s = sphere_t(rho, x, radius) 13 | 14 | print *, "Sphere density ", s%object_t%rho 15 | print *, "Sphere density ", s%rho 16 | print *, "Sphere radius ", s%a 17 | 18 | s = sphere_t(a = radius, rho = rho , x = x) 19 | 20 | print *, "Sphere density ", s%object_t%rho 21 | print *, "Sphere density ", s%rho 22 | print *, "Sphere radius ", s%a 23 | 24 | obj = object_t(2.5, [1.0, 1.0, 1.0]) 25 | s = sphere_t(obj, radius) 26 | 27 | print *, "Sphere density ", s%rho 28 | print *, "Sphere position: ", s%x 29 | print *, "Sphere radius ", s%a 30 | 31 | end program test1 32 | -------------------------------------------------------------------------------- /_includes/life_cycle.html: -------------------------------------------------------------------------------- 1 | 2 | {% if site.life_cycle == "pre-alpha" %} 3 | 4 |
5 |
9 |
10 |
11 | {% elsif site.life_cycle == "alpha" %}
12 |
13 |
6 | This lesson is still being designed and assembled (Pre-Alpha version)
7 |
8 |
14 |
18 |
19 |
20 | {% elsif site.life_cycle == "beta" %}
21 |
22 |
15 | This lesson is in the early stages of development (Alpha version)
16 |
17 |
23 |
27 |
28 | {% elsif site.life_cycle == "stable" %}
29 |
30 | {% comment %}
31 | We don't do anything special for now
32 | {% endcomment %}
33 |
34 | {% endif %}
35 |
--------------------------------------------------------------------------------
/exercises/12-type-parameters/example1.f90:
--------------------------------------------------------------------------------
1 | program exmaple1
2 |
3 | use iso_fortran_env
4 | implicit none
5 |
6 | type :: my_array_t(kr, nlen)
7 | integer, kind :: kr
8 | integer, len :: nlen
9 | real (kr) :: data(nlen)
10 | end type my_array_t
11 |
12 | integer :: kr
13 | integer :: nlen
14 | type (my_array_t(kr = real64, nlen = 1000)) :: a
15 |
16 | print *, "kind a", a%kr
17 | print *, "nlen a", a%nlen
18 |
19 | write (*, "(a)", advance = "no") "kind: "
20 | read (*, *) kr
21 | write (*, "(a)", advance = "no") "nlen: "
22 | read (*, *) nlen
23 |
24 | call defer_me(kr, nlen)
25 |
26 | contains
27 |
28 | subroutine defer_me(kr, nlen)
29 |
30 | integer, intent(in) :: kr
31 | integer, intent(in) :: nlen
32 | type (my_array_t(kr, nlen)) :: b
33 |
34 | print *, "Defer me ", b%kr
35 | print *, "Length ", b%nlen
36 |
37 | end subroutine defer_me
38 |
39 | end program exmaple1
40 |
--------------------------------------------------------------------------------
/_includes/episode_overview.html:
--------------------------------------------------------------------------------
1 | {% comment %}
2 | Display an episode's timings and learning objectives.
3 | {% endcomment %}
4 |
24 | This lesson is being piloted (Beta version)
25 |
26 | 5 |37 | -------------------------------------------------------------------------------- /exercises/07-type-bound-procedures/example1.f90: -------------------------------------------------------------------------------- 1 | program test1 2 | 3 | use object_type 4 | implicit none 5 | 6 | type (object_t) :: obj 7 | type (sphere_t) :: s 8 | real :: rho = 1.0 9 | real :: x(3) = [ 2.0, 3.0, 4.0 ] 10 | real :: radius = 1.5 11 | 12 | s = sphere_t(rho, x, radius) 13 | 14 | print *, "Sphere density ", s%object_t%rho 15 | print *, "Sphere density ", s%rho 16 | print *, "Sphere radius ", s%a 17 | 18 | s = sphere_t(a = radius, rho = rho , x = x) 19 | 20 | print *, "Sphere density ", s%object_t%rho 21 | print *, "Sphere density ", s%rho 22 | print *, "Sphere radius ", s%a 23 | 24 | obj = object_t(2.5, [1.0, 1.0, 1.0]) 25 | s = sphere_t(obj, radius) 26 | 27 | print *, "Sphere density ", s%rho 28 | print *, "Sphere position: ", s%x 29 | print *, "Sphere radius ", s%a 30 | 31 | print *, "Object volume ", obj%volume() 32 | !print *, "Sphere volume ", s%volume() 33 | 34 | end program test1 35 | -------------------------------------------------------------------------------- /_includes/workshop_ad.html: -------------------------------------------------------------------------------- 1 | {% comment %} 2 | Advertising box at the top of a workshop website home page. 3 | {% endcomment %} 4 |Overview
6 | 7 |8 |22 | 23 |9 | Teaching: {{ page.teaching }} min 10 |13 |
11 | Exercises: {{ page.exercises }} min 12 |14 | Questions 15 |21 |16 | {% for question in page.questions %} 17 |
20 |- {{ question|markdownify }}
18 | {% endfor %} 19 |24 |35 | 36 |25 |26 |27 | Objectives 28 |34 |29 | {% for objective in page.objectives %} 30 |
33 |- {{ objective|markdownify }}
31 | {% endfor %} 32 |
5 |
33 |
--------------------------------------------------------------------------------
/bin/boilerplate/README.md:
--------------------------------------------------------------------------------
1 | # FIXME Lesson title
2 |
3 | [](https://swc-slack-invite.herokuapp.com/)
4 |
5 | FIXME
6 |
7 | ## Contributing
8 |
9 | We welcome all contributions to improve the lesson! Maintainers will do their best to help you if you have any
10 | questions, concerns, or experience any difficulties along the way.
11 |
12 | We'd like to ask you to familiarize yourself with our [Contribution Guide](CONTRIBUTING.md) and have a look at
13 | the [more detailed guidelines][lesson-example] on proper formatting, ways to render the lesson locally, and even
14 | how to write new episodes.
15 |
16 | ## Maintainer(s)
17 |
18 | * FIXME
19 |
20 | ## Authors
21 |
22 | A list of contributors to the lesson can be found in [AUTHORS](AUTHORS)
23 |
24 | ## Citation
25 |
26 | To cite this lesson, please consult with [CITATION](CITATION)
27 |
28 | [lesson-example]: https://carpentries.github.io/lesson-example
29 |
--------------------------------------------------------------------------------
/bin/boilerplate/.travis.yml:
--------------------------------------------------------------------------------
1 | # dist: trusty # Ubuntu 14.04
2 | language: python
3 | python: 3.7
4 | branches:
5 | only:
6 | - gh-pages
7 | - /.*/
8 | before_install:
9 | - sudo apt-key adv --keyserver keyserver.ubuntu.com --recv-keys E084DAB9
10 | - echo "deb https://cran.rstudio.com/bin/linux/ubuntu trusty/" | sudo tee -a /etc/apt/sources.list
11 | - sudo apt-get update -y
12 | - sudo apt-get install -y r-base
13 | - sudo Rscript -e "install.packages('knitr', repos = 'https://', dependencies = TRUE)"
14 | - sudo Rscript -e "install.packages('stringr', repos = 'https://cran.rstudio.com', dependencies = TRUE)"
15 | - sudo Rscript -e "install.packages('checkpoint', repos = 'https://cran.rstudio.com', dependencies = TRUE)"
16 | - sudo Rscript -e "install.packages('ggplot2', repos = 'https://cran.rstudio.com', dependencies = TRUE)"
17 | - rvm default
18 | - gem install json kramdown jekyll
19 | install:
20 | - pip install pyyaml
21 | script:
22 | - make lesson-check-all
23 | - make --always-make site
24 |
--------------------------------------------------------------------------------
/_includes/lc/schedule.html:
--------------------------------------------------------------------------------
1 |
6 |
32 |
7 |
31 | {{page.venue}}
8 |
9 |
30 |
10 |
13 | {{page.humandate}}
11 |{% if page.humantime %}{{page.humantime}}{% endif %}
12 |
14 |
29 | 15 | Instructors: 16 | {% if page.instructor %} 17 | {{page.instructor | join: ', ' %}} 18 | {% else %} 19 | to be announced. 20 | {% endif %} 21 |
22 | {% if page.helper %} 23 |24 | Helpers: 25 | {{page.helper | join: ', ' %}} 26 |
27 | {% endif %} 28 |
2 |
25 |
--------------------------------------------------------------------------------
/_includes/base_path.html:
--------------------------------------------------------------------------------
1 | {% comment %}
2 | This is adapted from: https://ricostacruz.com/til/relative-paths-in-jekyll
3 |
4 | `page.url` gives the URL of the current page with a leading /:
5 |
6 | - when the URL ends with the extension (e.g., /foo/bar.html) then we can get
7 | the depth by counting the number of / and remove - 1
8 | - when the URL ends with a / (e.g. /foo/bar/) then the number / gives the depth
9 | directly
10 | {% endcomment %}
11 |
12 | {% assign relative_root_path = '' %}
13 |
14 | {% assign last_char = page.url | slice: -1 %}
15 |
16 | {% if last_char == "/"}
17 | {% assign offset = 0 %}
18 | {% else %}
19 | {% assign offset = 1 %}
20 | {% endif %}
21 |
22 | {% assign depth = page.url | split: '/' | size | minus: offset %}
23 | {% if depth <= 1 %}{% assign relative_root_path = '.' %}
24 | {% elsif depth == 2 %}{% assign relative_root_path = '..' %}
25 | {% elsif depth == 3 %}{% assign relative_root_path = '../..' %}
26 | {% elsif depth == 4 %}{% assign relative_root_path = '../../..' %}
27 | {% endif %}
28 |
--------------------------------------------------------------------------------
/_includes/dc/schedule.html:
--------------------------------------------------------------------------------
1 |
3 |
5 |
12 |
13 | Day 1
4 || 09:00 | Data Intro for Librarians |
| 10:30 | Coffee |
| 12:00 | Lunch break |
| 13:00 | Shell Lessons for Libraries |
| 14:30 | Coffee |
| 16:00 | Wrap-up |
14 |
16 |
23 |
24 | Day 2
15 || 09:00 | Git Intro for Librarians |
| 10:30 | Coffee |
| 12:00 | Lunch break |
| 13:00 | OpenRefine for Librarians |
| 14:30 | Coffee |
| 16:00 | Wrap-up |
2 |
25 |
--------------------------------------------------------------------------------
/_includes/sc/schedule.html:
--------------------------------------------------------------------------------
1 |
3 |
5 |
12 |
13 | Day 1
4 || 09:00 | Automating tasks with the Unix shell |
| 10:30 | Coffee |
| 12:00 | Lunch break |
| 13:00 | Building programs with Python |
| 14:30 | Coffee |
| 16:00 | Wrap-up |
14 |
16 |
23 |
24 | Day 2
15 || 09:00 | Version control with Git |
| 10:30 | Coffee |
| 12:00 | Lunch break |
| 13:00 | Managing data with SQL |
| 14:30 | Coffee |
| 16:00 | Wrap-up |
2 |
25 |
--------------------------------------------------------------------------------
/exercises/04-derived-types/my_array_type.f90:
--------------------------------------------------------------------------------
1 | module my_array_type
2 |
3 | implicit none
4 | public
5 |
6 | type, public :: my_array_t
7 | integer :: nlen = 0
8 | real, allocatable :: values(:)
9 | end type my_array_t
10 |
11 | type, public :: my_array_pointer_t
12 | integer :: nlen = 0
13 | real, pointer :: values(:)
14 | end type my_array_pointer_t
15 |
16 | contains
17 |
18 | function my_array_allocate(nlen) result(a)
19 |
20 | integer, intent(in) :: nlen
21 | type (my_array_t) :: a
22 | integer :: i
23 |
24 | a%nlen = nlen
25 | a%values = [ (1.0*i, i = 1, nlen) ]
26 |
27 | end function my_array_allocate
28 |
29 | !----------------------------------------------------------------------------
30 |
31 | subroutine my_array_destroy(a)
32 |
33 | type (my_array_t), intent(inout) :: a
34 |
35 | a%nlen = 0
36 | if (allocated(a%values)) deallocate(a%values)
37 |
38 | end subroutine my_array_destroy
39 |
40 | end module my_array_type
41 |
--------------------------------------------------------------------------------
/exercises/04-derived-types/solutions/my_semi_opaque_type.f90:
--------------------------------------------------------------------------------
1 | module my_semi_opaque_type
2 |
3 | ! An example dervided type
4 |
5 | implicit none
6 | public
7 |
8 | type, public :: my_semi_opaque_t
9 | private
10 | integer :: idata
11 | integer, public :: ndata
12 | end type my_semi_opaque_t
13 |
14 | contains
15 |
16 | function my_semi_opaque(idata, ndata) result(res)
17 |
18 | integer, intent(in) :: idata
19 | integer, intent(in) :: ndata
20 | type (my_semi_opaque_t) :: res
21 |
22 | res%idata = idata
23 | res%ndata = ndata
24 |
25 | end function my_semi_opaque
26 |
27 | !----------------------------------------------------------------------------
28 |
29 | subroutine my_semi_opaque_print(label, a)
30 |
31 | character (len = *), intent(in) :: label
32 | type (my_semi_opaque_t), intent(in) :: a
33 |
34 | print *, "(var, idata, ndata): ", label, a%idata, a%ndata
35 |
36 | end subroutine my_semi_opaque_print
37 |
38 | end module my_semi_opaque_type
39 |
--------------------------------------------------------------------------------
/exercises/06-type-extension-polypmorphism/solutions/example2.f90:
--------------------------------------------------------------------------------
1 | program example2
2 |
3 | use object_type
4 | implicit none
5 |
6 | type (object_t), target :: obj = object_t()
7 | type (sphere_t), target :: s = sphere_t()
8 | type (charged_sphere_t), target :: cs
9 |
10 | class (object_t), pointer :: p => null()
11 | ! no can do ...
12 | !class (charged_sphere_t), pointer :: p => null()
13 |
14 |
15 | obj = object_t(rho = 1.0, x = [1.0, 2.0, 3.0])
16 | s = sphere_t(object_t = obj, a = 2.5)
17 | cs = charged_sphere_t(sphere_t = s, q = -1.0)
18 |
19 | p => obj
20 |
21 | print *, "object density ", p%rho
22 | print *, "object position ", p%x(:)
23 | !print *, "object radius ", p%a
24 |
25 | call object_info(p)
26 |
27 | p => s
28 |
29 | print *, "sphere density ", p%rho
30 | print *, "sphere position ", p%x(:)
31 | !print *, "sphere radius ", p%a
32 |
33 | call object_info(p)
34 |
35 | p => cs
36 | !print *, "sphere charge ", p%q
37 |
38 | call object_info(p)
39 |
40 | end program example2
41 |
--------------------------------------------------------------------------------
/exercises/06-type-extension-polypmorphism/solutions/object_type.f90:
--------------------------------------------------------------------------------
1 | module object_type
2 |
3 | implicit none
4 | public
5 |
6 | type, public :: object_t
7 | real :: rho = 1.0 ! density
8 | real :: x(3) = 0.0 ! position of centre of mass
9 | end type object_t
10 |
11 | type, extends(object_t), public :: sphere_t
12 | real :: a = 1.0 ! radius
13 | end type sphere_t
14 |
15 | type, extends(sphere_t), public :: charged_sphere_t
16 | real :: q = -1.0 ! charge
17 | end type charged_sphere_t
18 |
19 | contains
20 |
21 | subroutine object_info(p)
22 |
23 | class(object_t), pointer, intent(in) :: p
24 |
25 | select type (p)
26 | type is (charged_sphere_t)
27 | print *, "Charge = ", p%q
28 | class is (sphere_t)
29 | print *, "Radius = ", p%a
30 | class is (object_t)
31 | print *, "Density = ", p%rho
32 | print *, "Position = ", p%x
33 | class default
34 | print *, "Unknown object type!"
35 | end select
36 |
37 | end subroutine object_info
38 |
39 | end module object_type
40 |
--------------------------------------------------------------------------------
/exercises/14-interoperability-with-c/solutions/f_array.f90:
--------------------------------------------------------------------------------
1 | module f_array_module
2 | use, intrinsic :: iso_c_binding
3 | implicit none
4 | public
5 |
6 | interface
7 | subroutine c_array (mlen, nlen, idata) &
8 | bind(c, name = "c_array")
9 | use iso_c_binding, only : c_int
10 | integer (kind = c_int), value, intent(in) :: mlen, nlen
11 | integer (kind = c_int), intent(in) :: idata(mlen, *)
12 | end subroutine c_array
13 | end interface
14 |
15 | end module f_array_module
16 |
17 |
18 | program test_array
19 | use f_array_module
20 | implicit none
21 |
22 | integer, parameter :: mlen = 2, nlen = 3
23 | integer :: idata(mlen, nlen)
24 |
25 | integer :: i, j
26 |
27 | do j = 1, nlen
28 | do i = 1, mlen
29 | idata(i, j) = i + (j - 1) * mlen
30 | end do
31 | end do
32 |
33 | ! printing - check correct in memory order
34 | do j = 1, mlen
35 | write(*,*) "Row ", j, ": ", idata(j, 1:nlen)
36 | end do
37 | print *, idata
38 |
39 | call c_array(mlen, nlen, idata)
40 | end program test_array
--------------------------------------------------------------------------------
/exercises/14-interoperability-with-c/solutions/f_array_t.f90:
--------------------------------------------------------------------------------
1 | module f_array_t
2 |
3 | use iso_c_binding, only : c_int, c_float, c_ptr, c_f_pointer
4 | use iso_fortran_env, only : output_unit
5 | implicit none
6 |
7 | ! Interoperable Fortran counterpart to the C array_t.
8 | type, bind(c) :: array_t
9 | integer (c_int) :: nlen
10 | type (c_ptr) :: data
11 | end type array_t
12 |
13 | contains
14 |
15 | subroutine f_subroutine(a) bind(c)
16 | implicit none
17 |
18 | type (array_t), intent(in) :: a
19 | real (c_float), pointer :: data(:)
20 |
21 | integer :: i
22 |
23 | ! Get a Fortran pointer counterpart to the C pointer.
24 | ! As it's a pointer to an array, we need to provide its size.
25 | call c_f_pointer(a%data, data, [ a%nlen ])
26 |
27 | ! Print the array's contents. It should match what was
28 | ! printed from the C code.
29 | write(output_unit, "('Fortran pointer to array of size ', i2, ':')") a%nlen
30 | do i = 1, a%nlen
31 | write (output_unit, "('Element (',i2,')',x,f4.1)") i, data(i)
32 | end do
33 |
34 | end subroutine f_subroutine
35 |
36 | end module f_array_t
--------------------------------------------------------------------------------
/assets/img/cp-logo-blue.svg:
--------------------------------------------------------------------------------
1 |
2 |
--------------------------------------------------------------------------------
/bin/lesson_initialize.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 |
3 | """Initialize a newly-created repository."""
4 |
5 |
6 | import sys
7 | import os
8 | import shutil
9 |
10 | BOILERPLATE = (
11 | '.travis.yml',
12 | 'AUTHORS',
13 | 'CITATION',
14 | 'CONTRIBUTING.md',
15 | 'README.md',
16 | '_config.yml',
17 | '_episodes/01-introduction.md',
18 | '_extras/about.md',
19 | '_extras/discuss.md',
20 | '_extras/figures.md',
21 | '_extras/guide.md',
22 | 'aio.md',
23 | 'index.md',
24 | 'reference.md',
25 | 'setup.md',
26 | )
27 |
28 |
29 | def main():
30 | """Check for collisions, then create."""
31 |
32 | # Check.
33 | errors = False
34 | for path in BOILERPLATE:
35 | if os.path.exists(path):
36 | print('Warning: {0} already exists.'.format(path), file=sys.stderr)
37 | errors = True
38 | if errors:
39 | print('**Exiting without creating files.**', file=sys.stderr)
40 | sys.exit(1)
41 |
42 | # Create.
43 | for path in BOILERPLATE:
44 | shutil.copyfile(
45 | "bin/boilerplate/{}".format(path),
46 | path
47 | )
48 |
49 |
50 | if __name__ == '__main__':
51 | main()
52 |
--------------------------------------------------------------------------------
/exercises/07-type-bound-procedures/solutions/example1.f90:
--------------------------------------------------------------------------------
1 | program test1
2 |
3 | use object_type
4 | implicit none
5 |
6 | type (object_t), target :: obj
7 | type (sphere_t), target :: s
8 | real :: rho = 1.0
9 | real :: x(3) = [ 2.0, 3.0, 4.0 ]
10 | real :: radius = 1.5
11 |
12 | class (object_t), pointer :: p => null()
13 |
14 | s = sphere_t(rho, x, radius)
15 |
16 | print *, "Sphere density ", s%object_t%rho
17 | print *, "Sphere density ", s%rho
18 | print *, "Sphere radius ", s%a
19 |
20 | s = sphere_t(a = radius, rho = rho , x = x)
21 |
22 | print *, "Sphere density ", s%object_t%rho
23 | print *, "Sphere density ", s%rho
24 | print *, "Sphere radius ", s%a
25 |
26 | obj = object_t(2.5, [1.0, 1.0, 1.0])
27 | s = sphere_t(obj, radius)
28 |
29 | print *, "Sphere density ", s%rho
30 | print *, "Sphere position: ", s%x
31 | print *, "Sphere radius ", s%a
32 |
33 | print *, "Object volume ", obj%volume()
34 | print *, "Sphere volume ", s%volume()
35 | print *, "Sphere mass ", s%mass()
36 |
37 | p => s
38 | print *, "Sphere volume ", p%volume()
39 | print *, "Sphere mass ", p%mass()
40 |
41 | end program test1
42 |
--------------------------------------------------------------------------------
/exercises/11-unlimited-polymorphic-entities/solutions/key_value_program.f90:
--------------------------------------------------------------------------------
1 | program key_value_program
2 |
3 | ! Generate three key value pairs of different types, then
4 | ! add then to a list.
5 |
6 | use key_value_module
7 | implicit none
8 |
9 | type (key_value_t) :: kv1 = key_value_t()
10 | type (key_value_t) :: kv2 = key_value_t()
11 | type (key_value_t) :: kv3 = key_value_t()
12 | type (key_value_t) :: kv4
13 | type (key_value_t) :: kv5
14 |
15 | type (key_value_list_t) :: alist
16 |
17 | kv1 = key_value_t("kv1", 2)
18 | kv2 = key_value_t("kv2", 3.141)
19 | kv3 = key_value_t("kv3", "foo")
20 |
21 | kv4 = key_value_t("kv4", 2.7)
22 | kv5 = key_value_t("kv5", kv4)
23 |
24 | call key_value_print(kv1)
25 | call key_value_print(kv2)
26 | call key_value_print(kv3)
27 | call key_value_print(kv4)
28 | call key_value_print(kv5)
29 |
30 | alist = key_value_list_t()
31 |
32 | call key_value_list_add_kv(alist, kv1)
33 | call key_value_list_add_kv(alist, kv2)
34 | call key_value_list_add_kv(alist, kv3)
35 |
36 | call key_value_release(kv3)
37 | call key_value_release(kv2)
38 | call key_value_release(kv1)
39 |
40 | call key_value_list_print(alist)
41 |
42 | end program key_value_program
43 |
--------------------------------------------------------------------------------
/exercises/10-modules-again/solutions/file_submodule.f90:
--------------------------------------------------------------------------------
1 | submodule (file_module) file_submodule
2 |
3 | use file_formatted
4 | use file_unformatted
5 | implicit none
6 |
7 | contains
8 |
9 | function create_file_formatted_writer_t() result(fp)
10 |
11 | class (file_formatted_writer_t), pointer :: fp
12 | allocate(fp)
13 |
14 | end function create_file_formatted_writer_t
15 |
16 | function create_file_unformatted_writer_t() result(fp)
17 |
18 | class (file_unformatted_writer_t), pointer :: fp
19 | allocate(fp)
20 |
21 | end function create_file_unformatted_writer_t
22 |
23 | !----------------------------------------------------------------------------
24 |
25 | module function file_writer_from_string(str) result(fp)
26 |
27 | character (len = *), intent(in) :: str
28 | class (file_writer_t), pointer :: fp
29 |
30 | ! We haven't reached typed allocation yet, hence the extra
31 | ! routines to return a pointer of the right type.
32 | fp => null()
33 | select case (str)
34 | case ("formatted")
35 | fp => create_file_formatted_writer_t()
36 | case ("unformatted")
37 | fp => create_file_unformatted_writer_t()
38 | case default
39 | print *, "Not recognised ", str
40 | end select
41 |
42 | end function file_writer_from_string
43 |
44 | end submodule file_submodule
45 |
--------------------------------------------------------------------------------
/aio.md:
--------------------------------------------------------------------------------
1 | ---
2 | ---
3 |
4 | {% include base_path.html %}
5 |
6 |
32 | {% comment %}
33 | Create an anchor for every episode.
34 | {% endcomment %}
35 | {% for episode in site.episodes %}
36 |
37 | {% endfor %}
38 |
--------------------------------------------------------------------------------
/bin/boilerplate/aio.md:
--------------------------------------------------------------------------------
1 | ---
2 | ---
3 |
4 | {% include base_path.html %}
5 |
6 |
32 | {% comment %}
33 | Create an anchor for every episode.
34 | {% endcomment %}
35 | {% for episode in site.episodes %}
36 |
37 | {% endfor %}
38 |
--------------------------------------------------------------------------------
/exercises/04-derived-types/solutions/my_array_type.f90:
--------------------------------------------------------------------------------
1 | module my_array_type
2 |
3 | implicit none
4 | public
5 |
6 | type, public :: my_array_t
7 | integer :: nlen = 0
8 | real, allocatable :: values(:)
9 | end type my_array_t
10 |
11 | type, public :: my_array_pointer_t
12 | integer :: nlen = 0
13 | real, pointer :: values(:)
14 | end type my_array_pointer_t
15 |
16 | interface assignment (=)
17 | module procedure my_assignment
18 | end interface assignment (=)
19 |
20 | contains
21 |
22 | function my_array_allocate(nlen) result(a)
23 |
24 | integer, intent(in) :: nlen
25 | type (my_array_t) :: a
26 | integer :: i
27 |
28 | a%nlen = nlen
29 | a%values = [ (1.0*i, i = 1, nlen) ]
30 |
31 | end function my_array_allocate
32 |
33 | !----------------------------------------------------------------------------
34 |
35 | subroutine my_array_destroy(a)
36 |
37 | type (my_array_t), intent(inout) :: a
38 |
39 | a%nlen = 0
40 | if (allocated(a%values)) deallocate(a%values)
41 |
42 | end subroutine my_array_destroy
43 |
44 | !----------------------------------------------------------------------------
45 |
46 | subroutine my_assignment(a, b)
47 |
48 | type (my_array_pointer_t), intent(out) :: a
49 | type (my_array_t), target, intent(in) :: b
50 |
51 | a%nlen = b%nlen
52 | a%values => b%values
53 |
54 | end subroutine my_assignment
55 |
56 | end module my_array_type
57 |
--------------------------------------------------------------------------------
/exercises/07-type-bound-procedures/solutions/object_type.f90:
--------------------------------------------------------------------------------
1 | module object_type
2 |
3 | implicit none
4 | public
5 |
6 | type, public :: object_t
7 | real :: rho = 1.0 ! density
8 | real :: x(3) = 0.0 ! position of centre of mass
9 | contains
10 | procedure, pass :: volume => object_volume
11 | end type object_t
12 |
13 | type, extends(object_t), public :: sphere_t
14 | real :: a = 1.0 ! radius
15 | contains
16 | procedure, pass, non_overridable :: volume => sphere_volume
17 | procedure, pass :: mass => sphere_mass
18 | end type sphere_t
19 |
20 | type, extends(sphere_t), public :: charged_sphere_t
21 | real :: q = -1.0 ! charge
22 | end type charged_sphere_t
23 |
24 | contains
25 |
26 | function object_volume(self) result(volume)
27 |
28 | class (object_t), intent(in) :: self
29 | real :: volume
30 |
31 | volume = 0.0
32 |
33 | end function object_volume
34 |
35 | function sphere_volume(self) result(volume)
36 |
37 | class (sphere_t), intent(in) :: self
38 | real :: volume
39 |
40 | volume = (4.0/3.0)*(4.0*atan(1.0))*self%a**3
41 |
42 | end function sphere_volume
43 |
44 | function sphere_mass(self) result(mass)
45 |
46 | class (sphere_t), intent(in) :: self
47 | real :: mass
48 |
49 | mass = self%rho*self%volume()
50 |
51 | end function sphere_mass
52 |
53 | end module object_type
54 |
--------------------------------------------------------------------------------
/exercises/10-modules-again/solutions/file_module.f90:
--------------------------------------------------------------------------------
1 | module file_module
2 |
3 | implicit none
4 | public
5 |
6 | type, abstract, public :: file_writer_t
7 | contains
8 | procedure (if_open), pass, deferred :: open
9 | procedure (if_write), pass, deferred :: write
10 | procedure (if_close), pass, deferred :: close
11 | end type file_writer_t
12 |
13 | abstract interface
14 | function if_open(self, filename) result(ierr)
15 | import file_writer_t
16 | class (file_writer_t), intent(inout) :: self
17 | character (len = *), intent(in) :: filename
18 | integer :: ierr
19 | end function if_open
20 |
21 | function if_write(self, data) result(ierr)
22 | import file_writer_t
23 | class (file_writer_t), intent(inout) :: self
24 | integer, intent(in) :: data(:)
25 | integer :: ierr
26 | end function if_write
27 |
28 | function if_close(self) result(ierr)
29 | import file_writer_t
30 | class (file_writer_t), intent(inout) :: self
31 | integer :: ierr
32 | end function if_close
33 | end interface
34 |
35 | ! Factory method
36 |
37 | interface
38 | module function file_writer_from_string(str) result(fp)
39 | character (len = *), intent(in) :: str
40 | class (file_writer_t), pointer :: fp
41 | end function file_writer_from_string
42 | end interface
43 |
44 | end module file_module
45 |
--------------------------------------------------------------------------------
/_includes/episode_navbar.html:
--------------------------------------------------------------------------------
1 | {% comment %}
2 | For some reason, the relative_root_path seems out of scope in this file, so we
3 | need to re-assign it here
4 | {% endcomment %}
5 |
6 | {% include base_path.html %}
7 |
8 | {% comment %}
9 | Navigation bar for an episode.
10 | {% endcomment %}
11 |
12 |
3 |
5 |
12 |
13 | Day 1
4 || 09:00 | Automating tasks with the Unix shell |
| 10:30 | Coffee |
| 12:00 | Lunch break |
| 13:00 | Building programs with Python |
| 14:30 | Coffee |
| 16:00 | Wrap-up |
14 |
16 |
23 |
24 | Day 2
15 || 09:00 | Version control with Git |
| 10:30 | Coffee |
| 12:00 | Lunch break |
| 13:00 | Managing data with SQL |
| 14:30 | Coffee |
| 16:00 | Wrap-up |
13 |
37 |
--------------------------------------------------------------------------------
/exercises/13-intrinsic-modules/print_iso_fortran_env.f90:
--------------------------------------------------------------------------------
1 | program print_iso_fortran_env
2 |
3 | use, intrinsic :: iso_fortran_env
4 | implicit none
5 |
6 | character (len = *), parameter :: compiler = compiler_version()
7 | character (len = *), parameter :: options = compiler_options()
8 |
9 | print "('Error unit ', i8)", error_unit
10 | print "('Input unit ', i8)", input_unit
11 | print "('Output unit ', i8)", output_unit
12 |
13 | print "('iostat_end ', i8)", iostat_end
14 | print "('iostat_eor ', i8)", iostat_eor
15 |
16 | print "('character storage size ', i8)", character_storage_size
17 | print "('file storage size ', i8)", file_storage_size
18 | print "('numerical storage size ', i8)", numeric_storage_size
19 |
20 | print "('int8 ', i8)", int8
21 | print "('int16 ', i8)", int16
22 | print "('int32 ', i8)", int32
23 | print "('int64 ', i8)", int64
24 | print "('size(integer_kinds) ', i8)", size(integer_kinds)
25 |
26 | print "('real32 ', i8)", real32
27 | print "('real64 ', i8)", real64
28 | print "('real128 ', i8)", real128
29 | print "('size(real_kinds) ', i8)", size(real_kinds)
30 |
31 | print "('size(logical_kinds) ', i8)", size(logical_kinds)
32 | print "('size(character_kinds) ', i8)", size(character_kinds)
33 |
34 | print "('compiler_version(): ', a)", compiler
35 | print "('compiler_options(): ', a)", options
36 |
37 | end program print_iso_fortran_env
38 |
--------------------------------------------------------------------------------
/exercises/10-modules-again/solutions/file_formatted.f90:
--------------------------------------------------------------------------------
1 | module file_formatted
2 |
3 | use file_module
4 | implicit none
5 | private
6 |
7 | type, extends(file_writer_t), public :: file_formatted_writer_t
8 | private
9 | integer :: myunit
10 | contains
11 | procedure, pass :: open => open_formatted
12 | procedure, pass :: write => write_formatted
13 | procedure, pass :: close => close_formatted
14 | end type file_formatted_writer_t
15 |
16 | contains
17 |
18 | !----------------------------------------------------------------------------
19 |
20 | function open_formatted(self, filename) result(ierr)
21 |
22 | class (file_formatted_writer_t), intent(inout) :: self
23 | character (len = *), intent(in) :: filename
24 | integer :: ierr
25 |
26 | open (newunit = self%myunit, file = filename, form = 'formatted', &
27 | status = "replace", action = 'write', iostat = ierr)
28 |
29 | end function open_formatted
30 |
31 | function write_formatted(self, data) result(ierr)
32 |
33 | class (file_formatted_writer_t), intent(inout) :: self
34 | integer, intent(in) :: data(:)
35 | integer :: ierr
36 |
37 | write (unit = self%myunit, fmt = *, iostat = ierr) data(:)
38 |
39 | end function write_formatted
40 |
41 | function close_formatted(self) result(ierr)
42 |
43 | class (file_formatted_writer_t), intent(inout) :: self
44 | integer :: ierr
45 |
46 | close (unit = self%myunit, status = 'keep', iostat = ierr)
47 |
48 | end function close_formatted
49 |
50 | end module file_formatted
51 |
--------------------------------------------------------------------------------
/exercises/14-interoperability-with-c/print_iso_c_binding.f90:
--------------------------------------------------------------------------------
1 | program print_iso_c_binding
2 |
3 | ! The contents of iso_c_binding
4 |
5 | use iso_c_binding
6 | implicit none
7 |
8 | print "('c_int ', i8)", c_int
9 | print "('c_short ', i8)", c_short
10 | print "('c_long ', i8)", c_long
11 | print "('c_long_long ', i8)", c_long_long
12 | print "('c_signed_char ', i8)", c_signed_char
13 | print "('c_size_t ', i8)", c_size_t
14 | print "('c_int8_t ', i8)", c_int8_t
15 | print "('c_int32_t ', i8)", c_int32_t
16 | print "('c_int64_t ', i8)", c_int64_t
17 | print "('c_int_least8_t ', i8)", c_int_least8_t
18 | print "('c_int_least16_t ', i8)", c_int_least16_t
19 | print "('c_int_least32_t ', i8)", c_int_least32_t
20 | print "('c_int_least64_t ', i8)", c_int_least64_t
21 | print "('c_int_fast8_t ', i8)", c_int_fast8_t
22 | print "('c_int_fast16_t ', i8)", c_int_fast16_t
23 | print "('c_int_fast32_t ', i8)", c_int_fast32_t
24 | print "('c_int_fast64_t ', i8)", c_int_fast64_t
25 | print "('c_intmax_t ', i8)", c_intmax_t
26 | print "('c_intptr_t ', i8)", c_intptr_t
27 |
28 | print "('c_float ', i8)", c_float
29 | print "('c_double ', i8)", c_double
30 | print "('c_long_double ', i8)", c_long_double
31 |
32 | print "('c_float_complex ', i8)", c_float_complex
33 | print "('c_double_complex ', i8)", c_double_complex
34 | print "('c_long_double_complex ', i8)", c_long_double_complex
35 |
36 | print "('c_bool ', i8)", c_bool
37 | print "('c_char ', i8)", c_char
38 |
39 | end program print_iso_c_binding
40 |
--------------------------------------------------------------------------------
/_includes/gh_variables.html:
--------------------------------------------------------------------------------
1 | {% comment %}
2 | When rendering websites locally, `site.github.url` doesn't get resolved properly
3 | unless a GitHub Personal Access Token is set up and available in the
4 | environment. This leads to warnings and errors when trying to serve the site
5 | locally. To work around this, we use the `jekyll.environment` variable which is
6 | set to `development` when rendering the site locally, and set to `production` on
7 | GitHub where `site.github.url` is defined.
8 | {% endcomment %}
9 |
10 | {% if jekyll.environment == "production" %}
11 |
12 | {% comment %}
13 | First, get the name of the repository
14 | {% endcomment %}
15 | {% assign repo_name = site.github.repository_name %}
16 |
17 | {% comment %}
18 | `site.github.public_repositories` contains comprehensive information for all public repositories for the organization. We use `where` to extract the part
19 | of the metadata that is relevant to the present repository.
20 | {% endcomment %}
21 | {% assign repo_info = site.github.public_repositories | where: "name", repo_name %}
22 |
23 | {% comment %}
24 | Now, we can extract the default branch for the repo
25 | {% endcomment %}
26 | {% assign default_branch = repo_info[0].default_branch %}
27 |
28 | {% comment %}
29 | Other variables requested by the template
30 | {% endcomment %}
31 | {% assign repo_url = site.github.repository_url %}
32 | {% assign search_domain_url = site.github.url %}
33 | {% assign project_title = site.github.project_title %}
34 | {% assign source_branch = site.github.source.branch %}
35 |
36 | {% elsif jekyll.environment == "development" %}
37 |
38 | {% assign repo_name = "" %}
39 | {% assign repo_url = "" %}
40 | {% assign default_branch = "" %}
41 | {% assign search_domain_url = "" %}
42 | {% assign project_title = "" %}
43 | {% assign source_branch = "" %}
44 |
45 | {% endif %}
46 |
--------------------------------------------------------------------------------
/_layouts/base.html:
--------------------------------------------------------------------------------
1 | ---
2 | ---
3 | {% include base_path.html %}
4 | {% include gh_variables.html %}
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 | {% include favicons.html %}
21 |
22 |
23 |
24 |
28 |
14 |
22 | 15 | {% if page.previous.url %} 16 | previous episode 17 | {% else %} 18 | lesson home 19 | {% endif %} 20 |
21 |
23 | {% if include.episode_navbar_title %}
24 |
27 | {{ site.title }}
25 | {% endif %} 26 |
28 |
36 | 29 | {% if page.next.url %} 30 | next episode 31 | {% else %} 32 | lesson home 33 | {% endif %} 34 |
35 |
35 | {% include navbar.html %}
36 | {{ content }}
37 | {% if site.kind == "workshop" %}
38 | {% include workshop_footer.html %}
39 | {% else %}
40 | {% include lesson_footer.html %}
41 | {% endif %}
42 |
43 | {% include javascript.html %}
44 |
45 |
46 |
--------------------------------------------------------------------------------
/assets/js/lesson.js:
--------------------------------------------------------------------------------
1 | // Make all tables striped by default.
2 | $("table").addClass("table table-striped");
3 |
4 |
5 | // Handle foldable challenges and solutions (on click and at start).
6 | $(".solution").click(function(event) {
7 | var trigger = $(event.target).has(".fold-unfold").size() > 0
8 | || $(event.target).filter(".fold-unfold").size() > 0;
9 | if (trigger) {
10 | $(">*:not(h2)", this).toggle(400);
11 | $(">h2>span.fold-unfold", this).toggleClass("glyphicon-collapse-down glyphicon-collapse-up");
12 | event.stopPropagation();
13 | }
14 | });
15 | $(".solution").each(function() {
16 | $(">*:not(h2)", this).toggle();
17 | var h2 = $("h2:first", this);
18 | h2.append("");
19 | });
20 |
21 |
22 | // Handle searches.
23 | // Relies on document having 'meta' element with name 'search-domain'.
24 | function google_search() {
25 | var query = document.getElementById("google-search").value;
26 | var domain = $("meta[name=search-domain]").attr("value");
27 | window.open("https://www.google.com/search?q=" + query + "+site:" + domain);
28 | }
29 |
30 | // function to shrink the life cycle bar when scrolling
31 | $(function(){
32 | $('#life-cycle').data('size','big');
33 | });
34 |
35 | $(window).scroll(function(){
36 | if($(document).scrollTop() > 0)
37 | {
38 | if($('#life-cycle').data('size') == 'big')
39 | {
40 | $('#life-cycle').data('size','small');
41 | $('#life-cycle').stop().animate({
42 | padding: '5px'
43 | },100);
44 | }
45 | }
46 | else
47 | {
48 | if($('#life-cycle').data('size') == 'small')
49 | {
50 | $('#life-cycle').data('size','big');
51 | $('#life-cycle').stop().animate({
52 | padding: '15px'
53 | },100);
54 | }
55 | }
56 | });
57 |
--------------------------------------------------------------------------------
/exercises/10-modules-again/solutions/file_unformatted.f90:
--------------------------------------------------------------------------------
1 | module file_unformatted
2 |
3 | use file_module
4 | implicit none
5 | private
6 |
7 | type, extends(file_writer_t), public :: file_unformatted_writer_t
8 | private
9 | integer :: myunit
10 | contains
11 | procedure, pass :: open => open_unformatted
12 | procedure, pass :: write => write_unformatted
13 | procedure, pass :: close => close_unformatted
14 | end type file_unformatted_writer_t
15 |
16 | contains
17 |
18 | !----------------------------------------------------------------------------
19 |
20 | function open_unformatted(self, filename) result(ierr)
21 |
22 | class (file_unformatted_writer_t), intent(inout) :: self
23 | character (len = *), intent(in) :: filename
24 | integer :: ierr
25 |
26 | open (newunit = self%myunit, file = filename, form = 'unformatted', &
27 | status = "replace", action = 'write', iostat = ierr)
28 |
29 | end function open_unformatted
30 |
31 | function write_unformatted(self, data) result(ierr)
32 |
33 | class (file_unformatted_writer_t), intent(inout) :: self
34 | integer, intent(in) :: data(:)
35 | integer :: ierr
36 |
37 | write (unit = self%myunit, iostat = ierr) data(:)
38 |
39 | end function write_unformatted
40 |
41 | function close_unformatted(self) result(ierr)
42 |
43 | class (file_unformatted_writer_t), intent(inout) :: self
44 | integer :: ierr
45 |
46 | close (unit = self%myunit, status = 'keep', iostat = ierr)
47 |
48 | end function close_unformatted
49 |
50 | !----------------------------------------------------------------------------
51 |
52 | function create_file_unformatted_writer_t() result(fp)
53 |
54 | class (file_unformatted_writer_t), pointer :: fp
55 | allocate(fp)
56 |
57 | end function create_file_unformatted_writer_t
58 |
59 | end module file_unformatted
60 |
--------------------------------------------------------------------------------
/bin/generate_md_episodes.R:
--------------------------------------------------------------------------------
1 | generate_md_episodes <- function() {
2 |
3 | library("methods")
4 |
5 | if (!require("remotes", quietly = TRUE)) {
6 | install.packages("remotes", repos = c(CRAN = "https://cloud.r-project.org/"))
7 | }
8 |
9 | if (!require("requirements", quietly = TRUE)) {
10 | remotes::install_github("hadley/requirements")
11 | }
12 |
13 | required_pkgs <- unique(c(
14 | ## Packages for episodes
15 | requirements:::req_dir("_episodes_rmd"),
16 | ## Pacakges for tools
17 | requirements:::req_dir("bin")
18 | ))
19 |
20 | missing_pkgs <- setdiff(required_pkgs, rownames(installed.packages()))
21 |
22 | if (length(missing_pkgs)) {
23 | message("Installing missing required packages: ",
24 | paste(missing_pkgs, collapse=", "))
25 | install.packages(missing_pkgs)
26 | }
27 |
28 | if (require("knitr") && packageVersion("knitr") < '1.9.19')
29 | stop("knitr must be version 1.9.20 or higher")
30 |
31 | ## get the Rmd file to process from the command line, and generate the path for their respective outputs
32 | args <- commandArgs(trailingOnly = TRUE)
33 | if (!identical(length(args), 2L)) {
34 | stop("input and output file must be passed to the script")
35 | }
36 |
37 | src_rmd <- args[1]
38 | dest_md <- args[2]
39 |
40 | ## knit the Rmd into markdown
41 | knitr::knit(src_rmd, output = dest_md)
42 |
43 | # Read the generated md files and add comments advising not to edit them
44 | vapply(dest_md, function(y) {
45 | con <- file(y)
46 | mdfile <- readLines(con)
47 | if (mdfile[1] != "---")
48 | stop("Input file does not have a valid header")
49 | mdfile <- append(mdfile, "# Please do not edit this file directly; it is auto generated.", after = 1)
50 | mdfile <- append(mdfile, paste("# Instead, please edit",
51 | basename(y), "in _episodes_rmd/"), after = 2)
52 | writeLines(mdfile, con)
53 | close(con)
54 | return(paste("Warning added to YAML header of", y))
55 | },
56 | character(1))
57 | }
58 |
59 | generate_md_episodes()
60 |
--------------------------------------------------------------------------------
/exercises/08-generic-io-for-derived-types/solutions/date_module.f90:
--------------------------------------------------------------------------------
1 | module date_module
2 |
3 | ! A module which defines a simple date type, and overrides the
4 | ! default formatted write.
5 |
6 | implicit none
7 |
8 | type :: my_type
9 | integer :: day = 0
10 | integer :: month = 0
11 | integer :: year = 0
12 | contains
13 | procedure :: write_my_type
14 | generic :: write(formatted) => write_my_type
15 | end type my_type
16 |
17 | ! Define some months, so we can produce formats like "12 Dec 2022"
18 | character (len = 3), dimension(12), parameter :: months = &
19 | [character (len = 3) :: "Jan", "Feb", "Mar", "Apr", "May", "Jun", &
20 | "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" ]
21 | contains
22 |
23 | subroutine write_my_type(self, unit, iotype, vlist, iostat, iomsg)
24 |
25 | class (my_type), intent(in) :: self
26 | integer, intent(in) :: unit
27 | character (len = *), intent(in) :: iotype
28 | integer, intent(in) :: vlist(:)
29 | integer, intent(out) :: iostat
30 | character (len = *), intent(inout) :: iomsg
31 |
32 | character (len = *), parameter :: dfmt = "(i2.2,'/',i2.2,'/',i4)"
33 | iostat = 0 ! we will assume no errors occur (iomsg is unchanged)
34 |
35 | if (iotype == "LISTDIRECTED") then
36 | write(unit, fmt = dfmt, iostat = iostat) self%day, self%month, self%year
37 | else
38 | ! A dt-style format
39 | ! We will only consider the case of vlist(3)
40 | if (size(vlist) == 3) then
41 | block
42 | character (len = 20) :: userfmt
43 | write (userfmt, "(a,i1,a,i2,a,i1,a)") &
44 | "(i", vlist(1), ",a", vlist(2), ",i", vlist(3), ")"
45 | write(unit, userfmt, iostat = iostat) &
46 | self%day, months(self%month), self%year
47 | end block
48 | else
49 | ! Handle other conditions; we will just use the default format
50 | write (unit, dfmt, iostat = iostat) self%day, self%month, self%year
51 | end if
52 | end if
53 |
54 | end subroutine write_my_type
55 |
56 | end module date_module
57 |
--------------------------------------------------------------------------------
/exercises/14-interoperability-with-c/solutions/f_snprintf.f90:
--------------------------------------------------------------------------------
1 | program example1
2 |
3 | use iso_c_binding, only : c_int, c_char, c_size_t, c_float, c_double, c_null_char
4 | implicit none
5 |
6 | interface
7 | function f_snprintf_float(str, sz, cformat, x) &
8 | bind(c, name = "c_snprintf_float") result(nchar)
9 | use iso_c_binding, only : c_int, c_char, c_size_t, c_float
10 | character (kind = c_char, len = 1), intent(out) :: str(*)
11 | integer (kind = c_size_t), value, intent(in) :: sz
12 | character (kind = c_char, len = 1), intent(in) :: cformat(*)
13 | real (kind = c_float), value, intent(in) :: x
14 | integer (kind = c_int) :: nchar
15 | end function f_snprintf_float
16 |
17 | function f_snprintf_double(str, sz, cformat, x) &
18 | bind(c, name = "c_snprintf_double") result(nchar)
19 | use iso_c_binding, only : c_int, c_char, c_size_t, c_double
20 | character (kind = c_char, len = 1), intent(out) :: str(*)
21 | integer (kind = c_size_t), value, intent(in) :: sz
22 | character (kind = c_char, len = 1), intent(in) :: cformat(*)
23 | real (kind = c_double), value, intent(in) :: x
24 | integer (kind = c_int) :: nchar
25 | end function f_snprintf_double
26 | end interface
27 |
28 | integer (c_size_t), parameter :: sz = 80
29 | character (kind = c_char, len = sz) :: str = ""
30 | character (kind = c_char, len = 10) :: cformat
31 | real (c_float) :: x = 3.14e0
32 | real (c_double) :: y = 2.71d0
33 |
34 | integer (c_int) :: nwrite = 0
35 |
36 | print *, "Single precision:"
37 | cformat = "%5.3f"
38 | print *, "Format ", cformat
39 | nwrite = f_snprintf_float(str, sz, trim(cformat), x)
40 | print *, "Return value ", nwrite
41 | print *, "Index of null ", index(str, c_null_char)
42 | print *, "String ", trim(str), len_trim(str)
43 |
44 | print *, "Double precision:"
45 | cformat = "%22.15e"
46 | print *, "Format ", cformat
47 | nwrite = f_snprintf_double(str, sz, trim(cformat), y)
48 | print *, "Return value ", nwrite
49 | print *, "Index of null ", index(str, c_null_char)
50 | print *, "String ", trim(str), len_trim(str)
51 |
52 | end program example1
53 |
--------------------------------------------------------------------------------
/_extras/figures.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Figures
3 | ---
4 |
5 | {% include base_path.html %}
6 |
7 |
61 | {% comment %}
62 | Create anchor for each one of the episodes.
63 | {% endcomment %}
64 | {% for episode in site.episodes %}
65 |
66 | {% endfor %}
67 |
68 | {% include links.md %}
69 |
--------------------------------------------------------------------------------
/bin/boilerplate/_extras/figures.md:
--------------------------------------------------------------------------------
1 | ---
2 | title: Figures
3 | ---
4 |
5 | {% include base_path.html %}
6 |
7 |
61 | {% comment %}
62 | Create anchor for each one of the episodes.
63 | {% endcomment %}
64 | {% for episode in site.episodes %}
65 |
66 | {% endfor %}
67 |
68 | {% include links.md %}
69 |
--------------------------------------------------------------------------------
/bin/chunk-options.R:
--------------------------------------------------------------------------------
1 | # These settings control the behavior of all chunks in the novice R materials.
2 | # For example, to generate the lessons with all the output hidden, simply change
3 | # `results` from "markup" to "hide".
4 | # For more information on available chunk options, see
5 | # http://yihui.name/knitr/options#chunk_options
6 |
7 | library("knitr")
8 |
9 | fix_fig_path <- function(pth) file.path("..", pth)
10 |
11 |
12 | ## We set the path for the figures globally below, so if we want to
13 | ## customize it for individual episodes, we can append a prefix to the
14 | ## global path. For instance, if we call knitr_fig_path("01-") in the
15 | ## first episode of the lesson, it will generate the figures in
16 | ## `fig/rmd-01-`
17 | knitr_fig_path <- function(prefix) {
18 | new_path <- paste0(opts_chunk$get("fig.path"),
19 | prefix)
20 | opts_chunk$set(fig.path = new_path)
21 | }
22 |
23 | ## We use the rmd- prefix for the figures generated by the lessons so
24 | ## they can be easily identified and deleted by `make clean-rmd`. The
25 | ## working directory when the lessons are generated is the root so the
26 | ## figures need to be saved in fig/, but when the site is generated,
27 | ## the episodes will be one level down. We fix the path using the
28 | ## `fig.process` option.
29 |
30 | opts_chunk$set(tidy = FALSE, results = "markup", comment = NA,
31 | fig.align = "center", fig.path = "fig/rmd-",
32 | fig.process = fix_fig_path,
33 | fig.width = 8.5, fig.height = 8.5,
34 | fig.retina = 2)
35 |
36 | # The hooks below add html tags to the code chunks and their output so that they
37 | # are properly formatted when the site is built.
38 |
39 | hook_in <- function(x, options) {
40 | stringr::str_c("\n\n~~~\n",
41 | paste0(x, collapse="\n"),
42 | "\n~~~\n{: .language-r}\n\n")
43 | }
44 |
45 | hook_out <- function(x, options) {
46 | x <- gsub("\n$", "", x)
47 | stringr::str_c("\n\n~~~\n",
48 | paste0(x, collapse="\n"),
49 | "\n~~~\n{: .output}\n\n")
50 | }
51 |
52 | hook_error <- function(x, options) {
53 | x <- gsub("\n$", "", x)
54 | stringr::str_c("\n\n~~~\n",
55 | paste0(x, collapse="\n"),
56 | "\n~~~\n{: .error}\n\n")
57 | }
58 |
59 | knit_hooks$set(source = hook_in, output = hook_out, warning = hook_error,
60 | error = hook_error, message = hook_out)
61 |
--------------------------------------------------------------------------------
/_layouts/workshop.html:
--------------------------------------------------------------------------------
1 | ---
2 | ---
3 | {% include base_path.html %}
4 | {% include gh_variables.html %}
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
26 | {% endif %}
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 | {% include favicons.html %}
38 |
39 |
40 |
41 |
45 |
49 | {% include navbar.html %}
50 | {% include workshop_ad.html %}
51 | {{ content }}
52 | {% include workshop_footer.html %}
53 |
54 | {% include javascript.html %}
55 |
56 |
57 |
--------------------------------------------------------------------------------
/_includes/lesson_footer.html:
--------------------------------------------------------------------------------
1 | {% comment %}
2 | Footer for lesson pages.
3 | {% endcomment %}
4 |
5 | {% include gh_variables.html %}
6 |
7 |
57 |
--------------------------------------------------------------------------------
/_includes/favicons.html:
--------------------------------------------------------------------------------
1 | {% assign favicon_url = relative_root_path | append: '/assets/favicons/' | append: site.carpentry %}
2 |
3 | {% if site.carpentry == 'swc' %}
4 | {% assign carpentry = 'Software Carpentry' %}
5 | {% elsif site.carpentry == 'dc' %}
6 | {% assign carpentry = 'Data Carpentry' %}
7 | {% elsif site.carpentry == 'lc' %}
8 | {% assign carpentry = 'Library Carpentry' %}
9 | {% elsif site.carpentry == 'cp' %}
10 | {% assign carpentry = 'The Carpentries' %}
11 | {% endif %}
12 |
13 |
35 |
--------------------------------------------------------------------------------
/_includes/lc/syllabus.html:
--------------------------------------------------------------------------------
1 |
2 |
27 |
28 |
3 |
14 | Data Intro
4 |-
5 |
- Intro to data 6 |
- Jargon busting 7 |
- Keyboard shortcuts 8 |
- Plain text formats 9 |
- Naming files 10 |
- Regular expressions 11 |
- Reference... 12 |
15 |
25 |
26 | The Unix Shell
16 |-
17 |
- Files and directories 18 |
- History and tab completion 19 |
- Counting and sorting contents in files 20 |
- Pipes and redirection 21 |
- Mining or searching in files 22 |
- Reference... 23 |
29 |
54 |
70 |
--------------------------------------------------------------------------------
/LICENSE.md:
--------------------------------------------------------------------------------
1 | ---
2 | layout: page
3 | title: "Licences"
4 | root: .
5 | ---
6 |
7 | ### Context
8 | This is not an official lesson of the Carpentries, however the licencing approach that the Carpentries take is ideal, so much of the material below resembles the Carpentries' documentation, where this is appropriate.
9 |
10 | ### Instructional Material
11 |
12 | All of the instructional material is
13 | made available under the [Creative Commons Attribution
14 | license][cc-by-human]. The following is a human-readable summary of
15 | (and not a substitute for) the [full legal text of the CC BY 4.0
16 | license][cc-by-legal].
17 |
18 | You are free:
19 |
20 | * to **Share**---copy and redistribute the material in any medium or format
21 | * to **Adapt**---remix, transform, and build upon the material
22 |
23 | for any purpose, even commercially.
24 |
25 | The licensor cannot revoke these freedoms as long as you follow the
26 | license terms.
27 |
28 | Under the following terms:
29 |
30 | * **Attribution**---You must give appropriate credit (mentioning that
31 | your work is derived from work that is Copyright © Software
32 | Carpentry and, where practical, linking to
33 | http://software-carpentry.org/), provide a [link to the
34 | license][cc-by-human], and indicate if changes were made. You may do
35 | so in any reasonable manner, but not in any way that suggests the
36 | licensor endorses you or your use.
37 |
38 | **No additional restrictions**---You may not apply legal terms or
39 | technological measures that legally restrict others from doing
40 | anything the license permits. With the understanding that:
41 |
42 | Notices:
43 |
44 | * You do not have to comply with the license for elements of the
45 | material in the public domain or where your use is permitted by an
46 | applicable exception or limitation.
47 | * No warranties are given. The license may not give you all of the
48 | permissions necessary for your intended use. For example, other
49 | rights such as publicity, privacy, or moral rights may limit how you
50 | use the material.
51 |
52 | ### Software
53 |
54 | The example programs within this lesson is made available under the
55 | [OSI][osi]-approved
56 | [MIT license][mit-license].
57 |
58 | Permission is hereby granted, free of charge, to any person obtaining
59 | a copy of this software and associated documentation files (the
60 | "Software"), to deal in the Software without restriction, including
61 | without limitation the rights to use, copy, modify, merge, publish,
62 | distribute, sublicense, and/or sell copies of the Software, and to
63 | permit persons to whom the Software is furnished to do so, subject to
64 | the following conditions:
65 |
66 | The above copyright notice and this permission notice shall be
67 | included in all copies or substantial portions of the Software.
68 |
69 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
70 | EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
71 | MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
72 | NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
73 | LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
74 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
75 | WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
76 |
77 | [cc-by-human]: https://creativecommons.org/licenses/by/4.0/
78 | [cc-by-legal]: https://creativecommons.org/licenses/by/4.0/legalcode
79 | [mit-license]: https://opensource.org/licenses/mit-license.html
80 | [ci]: http://communityin.org/
81 | [osi]: https://opensource.org
82 |
--------------------------------------------------------------------------------
/_includes/syllabus.html:
--------------------------------------------------------------------------------
1 | {% include base_path.html %}
2 |
3 | {% comment %}
4 | Display syllabus in tabular form.
5 | Days are displayed if at least one episode has 'start = true'.
6 | {% endcomment %}
7 |
30 |
41 | Version Control with Git
31 |-
32 |
- Creating a repository 33 |
- Configuring git 34 |
- Recording changes to files:
add,commit, ...
35 | - Viewing state changes with
status
36 | - Working on the web:
clone,pull,push, ...
37 | - Where to host work, and why 38 |
- Reference... 39 |
42 |
53 |
43 |
52 | Open Refine
44 |-
45 |
- Introduction to OpenRefine 46 |
- Importing data 47 |
- Basic functions 48 |
- Advanced Functions 49 |
- Reference... 50 |
8 |
19 |
75 |
76 |
81 |
--------------------------------------------------------------------------------
/_includes/dc/syllabus.html:
--------------------------------------------------------------------------------
1 | Schedule
9 | 10 | {% assign lesson_number = 0 %} 11 | {% assign day = 0 %} 12 | {% assign multiday = false %} 13 | {% for episode in site.episodes %} 14 | {% if episode.start %}{% assign multiday = true %}{% break %}{% endif %} 15 | {% endfor %} 16 | {% assign current = site.start_time %} 17 | 18 || {% endif %} 21 | | 22 | | Setup | 23 |Download files required for the lesson | 24 |
| {% endif %} 33 | | {% if hours < 10 %}0{% endif %}{{ hours }}:{% if minutes < 10 %}0{% endif %}{{ minutes }} | 34 |Finish | 35 |36 | |
| {% if episode.start %}Day {{ day }}{% endif %} | {% endif %} 44 |{% if hours < 10 %}0{% endif %}{{ hours }}:{% if minutes < 10 %}0{% endif %}{{ minutes }} | 45 |46 | {% assign lesson_number = lesson_number | plus: 1 %} 47 | {{ lesson_number }}. {{ episode.title }} 48 | | 49 |
50 | {% if episode.break %}
51 | Break
52 | {% else %}
53 | {% if episode.questions %}
54 | {% for question in episode.questions %}
55 | {{question|markdownify|strip_html}}
56 | {% unless forloop.last %}
57 | 58 | {% endunless %} 59 | {% endfor %} 60 | {% endif %} 61 | {% endif %} 62 | |
63 |
| {% endif %} 70 | | {% if hours < 10 %}0{% endif %}{{ hours }}:{% if minutes < 10 %}0{% endif %}{{ minutes }} | 71 |Finish | 72 |73 | |
77 | The actual schedule may vary slightly depending on the topics and exercises chosen by the instructor. 78 |
79 | 80 |
2 |
54 |
55 |
3 |
14 | The Unix Shell
4 |-
5 |
- Files and directories 6 |
- History and tab completion 7 |
- Pipes and redirection 8 |
- Looping over files 9 |
- Creating and running shell scripts 10 |
- Finding things 11 |
- Reference... 12 |
15 |
27 |
40 |
53 | Programming in Python
16 |-
17 |
- Using libraries 18 |
- Working with arrays 19 |
- Reading and plotting data 20 |
- Creating and using functions 21 |
- Loops and conditionals 22 |
- Defensive programming 23 |
- Using Python from the command line 24 |
- Reference... 25 |
56 |
97 |
--------------------------------------------------------------------------------
/_includes/sc/syllabus.html:
--------------------------------------------------------------------------------
1 |
57 |
70 |
86 | Version Control with Git
58 |-
59 |
- Creating a repository 60 |
- Recording changes to files:
add,commit, ...
61 | - Viewing changes:
status,diff, ...
62 | - Ignoring files 63 |
- Working on the web:
clone,pull,push, ...
64 | - Resolving conflicts 65 |
- Open licenses 66 |
- Where to host work, and why 67 |
- Reference... 68 |
87 |
96 | Open Refine
88 |-
89 |
- Introduction to OpenRefine 90 |
- Importing data 91 |
- Basic functions 92 |
- Advanced Functions 93 |
- Reference... 94 |
2 |
54 |
55 |
3 |
14 | The Unix Shell
4 |-
5 |
- Files and directories 6 |
- History and tab completion 7 |
- Pipes and redirection 8 |
- Looping over files 9 |
- Creating and running shell scripts 10 |
- Finding things 11 |
- Reference... 12 |
15 |
27 |
40 |
53 | Programming in Python
16 |-
17 |
- Using libraries 18 |
- Working with arrays 19 |
- Reading and plotting data 20 |
- Creating and using functions 21 |
- Loops and conditionals 22 |
- Defensive programming 23 |
- Using Python from the command line 24 |
- Reference... 25 |
56 |
97 |
--------------------------------------------------------------------------------
/_includes/navbar.html:
--------------------------------------------------------------------------------
1 | {% comment %}
2 | Lesson navigation bar.
3 | {% endcomment %}
4 |
5 | {% include gh_variables.html %}
6 |
7 |
76 |
--------------------------------------------------------------------------------
/_includes/carpentries.html:
--------------------------------------------------------------------------------
1 | {% comment %}
2 | General description of Software, Data, and Library Carpentry.
3 | {% endcomment %}
4 |
5 | {% include base_path.html %}
6 |
7 |
57 |
70 |
86 | Version Control with Git
58 |-
59 |
- Creating a repository 60 |
- Recording changes to files:
add,commit, ...
61 | - Viewing changes:
status,diff, ...
62 | - Ignoring files 63 |
- Working on the web:
clone,pull,push, ...
64 | - Resolving conflicts 65 |
- Open licenses 66 |
- Where to host work, and why 67 |
- Reference... 68 |
87 |
96 | Open Refine
88 |-
89 |
- Introduction to OpenRefine 90 |
- Importing data 91 |
- Basic functions 92 |
- Advanced Functions 93 |
- Reference... 94 |
8 |
28 |
9 | 
10 |
11 |
10 |
12 |
27 | The Carpentries comprises 13 | Software Carpentry, Data Carpentry, and Library Carpentry communities of Instructors, Trainers, 14 | Maintainers, helpers, and supporters who share a mission to teach 15 | foundational coding and data science skills to researchers and people 16 | working in library- and information-related roles. In January, 17 | 2018, The Carpentries was formed by the merger of Software Carpentry and 18 | Data Carpentry. Library Carpentry became an official Carpentries Lesson Program in November 2018.
19 | 20 |While individual lessons and workshops continue to be run under each 21 | lesson project, The Carpentries provide overall staffing and governance, as 22 | well as support for assessment, instructor training and mentoring. 23 | Memberships are joint, and the Carpentries project maintains a shared Code 24 | of Conduct. The Carpentries is a fiscally sponsored project of Community 25 | Initiatives, a registered 501(c)3 non-profit based in California, USA.
26 |
29 |
42 |
30 | 
31 |
32 |
31 |
33 |
41 | Since 1998, Software Carpentry has 34 | been teaching researchers across all disciplines the foundational coding 35 | skills they need to get more done in less time and with less pain. Its 36 | volunteer instructors have run hundreds of events for thousands of learners 37 | around the world. Now that all research involves some degree of 38 | computational work, whether with big data, cloud computing, or simple task 39 | automation, these skills are needed more than ever.
40 |43 |
44 |
57 |
45 | 
46 |
47 |
46 |
48 |
56 | Data Carpentry develops and teaches 49 | workshops on the fundamental data skills needed to conduct research. Its 50 | target audience is researchers who have little to no prior computational 51 | experience, and its lessons are domain specific, building on learners' 52 | existing knowledge to enable them to quickly apply skills learned to their 53 | own research. Data Carpentry workshops take researchers through the entire 54 | data life cycle.
55 |58 |
59 |
71 |
--------------------------------------------------------------------------------
/_config.yml:
--------------------------------------------------------------------------------
1 | #------------------------------------------------------------
2 | # Values for this lesson.
3 | #------------------------------------------------------------
4 |
5 | # Which carpentry is this ("swc", "dc", "lc", or "cp")?
6 | # swc: Software Carpentry
7 | # dc: Data Carpentry
8 | # lc: Library Carpentry
9 | # cp: Carpentries (to use for instructor training for instance)
10 | carpentry: "swc"
11 |
12 | # Overall title for pages.
13 | title: "Intermediate Modern Fortran"
14 |
15 | # Life cycle stage of the lesson
16 | # possible values: "pre-alpha", "alpha", "beta", "stable"
17 | life_cycle: "stable"
18 |
19 | #------------------------------------------------------------
20 | # Generic settings (should not need to change).
21 | #------------------------------------------------------------
22 |
23 | # What kind of thing is this ("workshop" or "lesson")?
24 | kind: "lesson"
25 |
26 | # Magic to make URLs resolve both locally and on GitHub.
27 | # See https://help.github.com/articles/repository-metadata-on-github-pages/.
28 | # Please don't change it:
60 | 
61 |
62 |
61 |
63 |
70 | Library Carpentry develops lessons and 64 | teaches workshops for and with people working in library- and 65 | information-related roles. Its goal is to create an on-ramp to empower this 66 | community to use software and data in their own work, as well as be 67 | advocates for and train others in efficient, effective and reproducible data 68 | and software practices.
69 |