The official Apple way of solving this is to first upgrade to Snow Leopard, and then use the App Store to buy and install Mountain Lion (ML). I did not want to do this for two reasons: I wanted a clean install, and I did not want to first upgrade to Snow Leopard. The following steps describe what I did to do a single step, clean install of Mountain Lion. Do note that this howto requires another Apple computer with Lion/Mountain Lion already installed, I will refer to this as the other machine.

1. Backup you data before following these steps as you will wipe the Leopard device’s hard drive. I would recommend not using a full backup such as Time Machine, but copy your homedrive to an external drive. A full backup will also backup and restore all kinds of old Leopard stuff. With a backup of your homedrive, you can then selectively copy back data such as photo’s.
2. Acquire Mountain Lion. If you already have ML, and the device you want to install it on is going to use your Apple ID, you do not need to rebuy ML. If, as in my case, the other computer is going to run under another Apple ID, you need to take the following steps:
   1. Open the App store on the other machine,
   2. log in with the Apple ID for which you want to buy ML
   3. buy ML. Note that ML will start downloading immediately, you can cancel this right now.
3. Create a recovery USB drive using the Recovery Disk Assistant that Apply provides. This needs at least 1GB of space.
4. Insert the USB drive into your Leopard device, and restart. During the boot sequence, press the Option key (alt) to gain access to the boot menu. Select the USB drive as boot device.
5. Once you’ve booted into the Recovery Assistant, go to the Disk Utility and wipe the boot partition (not the hard drive itself) on your hard drive.
6. Connect to your WiFi network or insert your network cable.
7. Go back to the main menu, and select the option to install ML. You will be asked to enter an Apple ID, enter the one relevant for this old Leopard device. This was my wife’s ID in my case. The Recovery Assistant will now download ML (can take some time, as it is 4.4 GB), and run through the installation procedure. This took around 3 hours for me. The machine will automatically reboot, and you will enter Mountain Lion heaven…

Notes:

- Do note that iLife with not be available after installing ML from scratch. You can, however, install iLife from the original installation DVD’s you got with your Apple device. You will get the old iLife version, the new, updated ones need to be purchased in the App Store if you follow this guide.

require(inline)  ## for cxxfunction()                                                       
                                                                                            
src = 'Rcpp::NumericVector vec = Rcpp::NumericVector(vec_in);                               
       double tmp = 0;                                                                      
       int no_swaps;                                                                        
       while(true) {                                                                        
           no_swaps = 0;                                                                    
           for (int i = 0; i < vec.size()-1; ++i) {                                         
               if(vec[i] > vec[i+1]) {                                                      
                   no_swaps++;                                                              
                   tmp = vec[i];                                                            
                   vec[i] = vec[i+1];                                                       
                   vec[i+1] = tmp;                                                          
               };                                                                           
           };                                                                               
           if(no_swaps == 0) break;                                                         
       };                                                                                   
       return(vec);'                                                                        
bubble_sort_cpp = cxxfunction(signature(vec_in = "numeric"), body=src, plugin="Rcpp")

Quite amazing how easy it is to integrate R code and C++ code. inline compiles and links the C++ code on-the-fly, creating an R function that delivers the functionality. Of course the most important question is now how fast this is. I use the microbenchmark package to run the bubble sort I implemented in pure R (here), the bubble sort implemented in C++ (see above), and the standard R sorting algorithm:

library(microbenchmark) 
vector_size = 100                                                                           
print(microbenchmark(bubble_sort(sample(1:vector_size)),                                    
               bubble_sort_cpp(sample(1:vector_size)),                                      
               sort(sample(1:vector_size))))  
                                   expr       min         lq     median
     bubble_sort(sample(1:vector_size)) 67397.546 74358.9495 78143.0710
 bubble_sort_cpp(sample(1:vector_size))    44.895    55.9340    60.4930
            sort(sample(1:vector_size))    44.173    48.1315    62.3785
         uq        max neval
 81285.0215 105626.483   100 
    63.7715     74.643   100 
    67.2375    138.069   100

These results speak for itself, the C++ version is more than 1300 times faster when looking at the median speed, even faster than the built-in sort function. These differences will only get more pronounced when the size of the vector grows.

1. Interpreted code with lots of iteration is very slow.
2. Bubble sort is one of the slowest sorting algorithms (O(N^2))

The bubble sort sorting algorithm works by iterating over the unsorted vector and comparing pairs of numbers. Let’s say the first point pair is c(61, 3), here the numbers need to be swapped as the 3 should be earlier in the sorted vector. The following function returns TRUE if the numbers should be swapped, and returns FALSE otherwise:

larger = function(pair) {
   if(pair[1] > pair[2]) return(TRUE) else return(FALSE)
}

This function is used by the following function:

swap_if_larger = function(pair) {
    if(larger(pair)) {
        return(rev(pair)) 
    } else {
        return(pair)
    }
}

which returns the swapped version of the pair if appropriate, or the original pair if the order is ok. For each point pair (element1-element2, element2-element3, etc) swap_if_larger is called:

swap_pass = function(vec) { 
    for(i in seq(1, length(vec)-1)) {
        vec[i:(i+1)] = swap_if_larger(vec[i:(i+1)])
    }
    return(vec)
}

One pass of this function performs a comparison on all pairs, swapping if necessary. To fully sort the vector, we need to perform multiple passes until no swaps are needed anymore. I chose to implement this using recursion:

bubble_sort = function(vec) {
    new_vec = swap_pass(vec)
    if(isTRUE(all.equal(vec, new_vec))) { 
        return(new_vec) 
    } else {
        return(bubble_sort(new_vec))
    }
}

The function starts by perform a swapping pass over the vector. If the new vector is equal to the old vector, no swaps where needed, i.e. the vector is already sorted. The function than returns the vector. Alternatively, if the vectors are different, the vector is not yet fully sorted, and we need to perform more passes. This is accomplished by recursively calling bubble_sort again on the vector. An example of the function in action:

> test_vec = round(runif(100, 0, 100))
> bubble_sort(test_vec)
  [1]  1  1  6  6  9 10 10 10 13 14 14 15 19 19 20 21 23 24 24 24 26 26 26 26 27
 [26] 28 28 30 31 32 34 35 35 36 36 37 39 39 40 40 40 41 41 41 41 43 43 43 45 46
 [51] 47 51 56 56 57 57 57 58 58 59 61 61 62 63 64 65 68 68 69 70 71 71 72 73 74
 [76] 75 75 75 78 79 82 82 84 85 88 88 89 90 91 91 91 92 92 92 92 93 93 96 96 99
>

The full sorting process is nicely illustrated by the following animated gif (linked from wikipedia):

This implementation is horribly slow:

> system.time(bubble_sort(test_vec))
   user  system elapsed
  0.076   0.000   0.077
> system.time(sort(test_vec))
   user  system elapsed
  0.001   0.000   0.001

Probably implementing the relatively slow bubble sort in a compiled language pose a dramatic increase in speed. Maybe a nice first testcase for Rcpp…

--langdef=IDL
--langmap=IDL:.pro
--regex-IDL=/^pro[ \t]+([a-zA-Z0-9_:]+)/\1/p,procedure/i
--regex-IDL=/^function[ \t]+([a-zA-Z0-9_:]+)/\1/f,function/i

to your ~/.ctags file to be able to use Ctags with IDL.

Assume we have the following matrix:

IDL> spam = DINDGEN(4,6)
IDL> print, spam
       0.0000000       1.0000000       2.0000000       3.0000000
       4.0000000       5.0000000       6.0000000       7.0000000
       8.0000000       9.0000000       10.000000       11.000000
       12.000000       13.000000       14.000000       15.000000
       16.000000       17.000000       18.000000       19.000000
       20.000000       21.000000       22.000000       23.000000

We can index this matrix in the following manner, observe that IDL indexing starts at zero:

IDL> print, spam[1,1]
       5.0000000

Providing an invalid index nicely leads to an exception:

IDL> print, spam[1000,1000]
% Attempt to subscript SPAM with <INT      (    1000)> is out of range.
% Execution halted at: $MAIN$

IDL is also vectorized, so we can pass vectors of indices to extract multiple values in one go:

IDL> print, spam[[1,1,3,2],[1,1,4,1]]
       5.0000000       5.0000000       19.000000       6.0000000

But now comes the problem. Let’s pass some out of range indices as vectors:

IDL> print, spam[[1000,5000,7000], [1000,2000,4000]]
       23.000000       23.000000       23.000000

In stead of throwing an exception, IDL happily returns the last valid value in that dimension, or in this case a pair of dimensions, i.e. 23. So, beware, when passing vectors of indices to an IDL array there is no out of range checking: you are on your own .

Take for example a snippet of this data which I downloaded from StackOverflow:

2  15466134 (10)
 2  15466134 (10)
 1  15462529 (15)
 2  13265177 (10)
 2  15475139 (10)
 2  15486973 (10)
-- 2013-03-18 rep +65   = 15552     
 2  14376993 (10)
 2  14376993 (10)
 2  14376993 (10)
 1  15493353 (15)
 2  12598625 (10)
 2  14376993 (10)
-- 2013-03-19 rep +65   = 15617     
 2  15520314 (10)
 2  15520314 (10)
-- 2013-03-20 rep +20   = 15637     
 1  15541210 (15)
 2  15541210 (10)
 2  15541210 (10)
 2  15541210 (10)

The entire data file can be downloaded here.

In this post I’ll be stepping through the R code needed to get this text data into a useable format. First, we want to read the data into a character vector:

all_data = readLines("rep.dat")
head(all_data)
[1] "total votes: 2325" " 2   8150378 (10)" " 2   8167111 (10)"
[4] " 2   8167111 (10)" " 2   8167111 (10)" " 2   8167461 (10)"

where each element of the vector is a line in the the text file. Already we see that the first line is some header information which we want to skip:

all_data = all_data[-1]

note the use of negative indexing to remove an element. Next we want to find all the elements in the vector that relate to the date for which the data is representative, we do that by using a regular expression which looks for lines that start with -:

rep_date_entries = grep("^-", all_data)

and find the amount of actions, upvotes or downvotes etc, that have taken place on each day, i.e. the index of a certain day minus the index of the day before that:

actions_per_day = c(rep_date_entries[1], diff(rep_date_entries)) - 1

note that we add rep_date_entries[1] because diff cuts off the first element. Now that we know which elements relate to the date, we can read all other lines into a nice data.frame:

dat = read.table(text = all_data[-rep_date_entries])  
names(dat) = c("action_id", "question_id", "rep_change")

The reputation column has a somewhat strange format ((10)), we need to get rid of the brackets. A nice way of doing that is using a regular expression, and the str_extract function from the stringr package:

require(stringr)
dat$rep_change = with(dat, as.numeric(str_extract(rep_change, "-*[0-9]+")))

The regular expression [0-9]+ matches one or more numbers, and str_extract gets the number out of the string. Now we have the data, we need to add a column which says for each row to which date it belongs. We know which lines in the data belong to a date (rep_date_entries) and we know how much data entries there are per day (actions_per_day). We can now simply repeat each element in rep_date_entries as many times as there are actions:

dat$rep_date = rep(all_data[rep_date_entries], times = actions_per_day)
head(dat)
  action_id question_id rep_change                             rep_date
1         2     8150378         10 -- 2011-11-17 rep +95   = 96
2         2     8167111         10 -- 2011-11-17 rep +95   = 96
3         2     8167111         10 -- 2011-11-17 rep +95   = 96
4         2     8167111         10 -- 2011-11-17 rep +95   = 96

You can see that the date is not yet in a nice format, we need to get rid of all the text, except the date itself. Again, we can use a regular expression, combined with str_extract for this:

dat$rep_date = str_extract(dat$rep_date, "[0-9]{4}-[0-9]{2}-[0-9]{2}")

The regular expression "[0-9]{4}-[0-9]{2}-[0-9]{2}" matches any occurence of 4 numbers-2 numbers-2 numbers. Finally, we transform the date from a string to a real date object using strptime:

dat$rep_date = strptime(dat$rep_date, "%Y-%m-%d")

The end result is the following data.frame:

head(dat)
  action_id question_id rep_change   rep_date
1         2     8150378         10 2011-11-17
2         2     8167111         10 2011-11-17
3         2     8167111         10 2011-11-17
4         2     8167111         10 2011-11-17
5         2     8167461         10 2011-11-17
6         1     8167461         15 2011-11-17
summary(dat)
   action_id       question_id         rep_change
 Min.   : 1.000   Min.   :  489821   Min.   :  0.000
 1st Qu.: 2.000   1st Qu.: 9521651   1st Qu.: 10.000
 Median : 2.000   Median :11738823   Median : 10.000
 Mean   : 2.336   Mean   :11475310   Mean   :  9.873
 3rd Qu.: 2.000   3rd Qu.:13175326   3rd Qu.: 10.000
 Max.   :16.000   Max.   :15541210   Max.   :100.000
    rep_date
 Min.   :2011-11-17 00:00:00
 1st Qu.:2012-04-08 00:00:00
 Median :2012-08-30 00:00:00
 Mean   :2012-08-02 19:55:59
 3rd Qu.:2012-11-16 00:00:00
 Max.   :2013-03-23 00:00:00

All this code together leads to the following function:

parse_so_rep_page = function(rep_file) {
   require(stringr)
   all_data = readLines(rep_file)
   all_data = all_data[-1]
   
   rep_date_entries = grep("^-", all_data)
   actions_per_day = c(rep_date_entries[1], diff(rep_date_entries)) - 1 
   
   dat = read.table(text = all_data[-rep_date_entries])
   names(dat) = c("action_id", "question_id", "rep_change")
   dat$rep_change = with(dat, as.numeric(str_extract(rep_change, "-*[0-9]+")))
   
   dat$rep_date = rep(all_data[rep_date_entries], times = actions_per_day)
   dat$rep_date = str_extract(dat$rep_date, "[0-9]{4}-[0-9]{2}-[0-9]{2}")
   dat$rep_date = strptime(dat$rep_date, "%Y-%m-%d")
   return(dat)
}
res = parse_so_rep_page("data/rep.dat")

I think this nicely illustrates the power of both vectorization, very short and to-the-point for-loop-less syntax, and regular expressions in editing strings.

Slate allows you to:

• Attach keystrokes to how you want to manage your windows: e.g. resizing, moving around the screen, shifting focus between apps.
• Create app layouts, e.g. Google Chrome full screen, Mail Client on my 2nd screen maximized to the left half of the screen, Terminal maximized to the right half of the screen, and being able to quickly switch between them. It also allows you to create layouts for 1 and 2 monitor setups, and switches between them automatically.
• Windows Hints, press a button and all the apps are marked by a letter. Pushing that letter shifts focus to that app.
• An alternative app switcher.

Configuring Slate is done using a .slate file in your homedirectory, and can be a bit daunting. But if you are used to working with .bash_profile‘s and such, you’ll feel right at home. I’ve only just starting to work with Slate, but you can have a look at my config file at the bottom of this post. A nice introductory blog post for Slate has been written by Tristan Hume.

One issue for me right now is that Slate does not work well with Mission Control (multiple workspaces). The features I use in the config file below work fine, but for example the layout’s aren’t able to use multiple workspaces. This is a known issue, and progress in this direction is hampered by the lack of API support from apple.

# Some config options
# Options relevant to Window hints
config windowHintsShowIcons true
config windowHintsIgnoreHiddenWindows false
config windowHintsSpread true

# Abstract positions
alias full move screenOriginX;screenOriginY screenSizeX;screenSizeY
alias lefthalf move screenOriginX;screenOriginY screenSizeX/2;screenSizeY
alias righthalf move screenOriginX+screenSizeX/2;screenOriginY screenSizeX/2;screenSizeY
alias topleft corner top-left resize:screenSizeX/2;screenSizeY/2
alias topright corner top-right resize:screenSizeX/2;screenSizeY/2
alias bottomleft corner bottom-left resize:screenSizeX/2;screenSizeY/2
alias bottomright corner bottom-right resize:screenSizeX/2;screenSizeY/2

# Bind window hinting to cmd+e, using the given letters
bind e:cmd hint ASDFGHJKLQWERTYUIOPCVBN # use whatever keys you want

# Press cmd+g to get a grid, drag on that 
# grid to determine the size of an app
bind g:cmd grid padding:5 0:6,2 1:8,2

# Use the Slate task switcher (beta)
bind tab:cmd switch

# Send a program to a particular screen
bind 1:alt,ctrl throw 0 resize
bind 2:alt,ctrl throw 1 resize

# Use the keys below to put the selected window
bind right:ctrl;alt  ${righthalf}   #...at the right half of the screen
bind left:ctrl;alt   ${lefthalf}    #...on the left half of the screen
bind up:ctrl;alt     ${full}        #...fullscreen

# Focus Bindings
# Shift focus to the app to the
bind right:cmd    focus right
bind left:cmd     focus left
bind up:cmd       focus up
bind down:cmd     focus down
bind up:cmd;alt   focus behind
bind down:cmd;alt focus behind

automap provides the following set of functions (for details I refer to the online manual):

• autofitVariogram, automatically fits the variogram model to the data.
• autoKrige, automatically fits the variogram model using autofitVariogram, and creates an interpolated map.
• autoKrige.cv, automatically fits the variogram model using autofitVariogram, and performs cross-validation. Uses krige.cv under the hood.
• compare.cv, allows comparison of the output of autoKrige.cv and krige.cv. This can be used to evaluate the performance of different interpolation algorithms. compare.cv allows comparison using both summary statistics and spatial plots.

In general, the interface of automap mimics that of gstat. The following code snippets show some examples of creating interpolated maps using automap:

library(automap)
loadMeuse()
# Ordinary kriging
kriging_result = autoKrige(zinc~1, meuse, meuse.grid)
plot(kriging_result)
# Universal kriging
kriging_result = autoKrige(zinc~soil+ffreq+dist, meuse, meuse.grid)
plot(kriging_result)

You can get automap from either CRAN:

install.packages("automap")

or my bitbucket account.

hg clone https://bitbucket.org/paulhiemstra/automap

PS: automap was the first package I wrote, at the beginning of my PhD, so it is not the most beautiful code I ever wrote .

I made the following changes:

• There is now just one subroutine to put stuff into the hash table: hash_set. When hash_set is called, the hash table tries to find the key, and if it is not found, the key-value pair is pushed onto the hash table. hash_push is no longer publicly available.
• Standard behavior now is that the hash table has a size of 50 items, and the table no longer has to be initialized at a certain size. In addition, when the 50 numbers are full, hash_reallocate is called to extend the hash table by another 50 items. This makes the hash table much more flexible.
• hash_print now only prints the key-value pairs that are actually used.

The following program shows the new hash table module in action:

PROGRAM hash_test
  use hash
  REAL :: res = 0.0

  CALL hash_init

  CALL hash_set("one", 1.0)
  CALL hash_set("two", 2.0)
  CALL hash_set("three", 3.0)

  CALL hash_print
  CALL hash_get("one", res)
  PRINT*, res
  CALL hash_get("two", res)
  PRINT*, res

  CALL hash_set("one", 60.0)

  CALL hash_print
  CALL hash_get("one", res)
  PRINT*, res
END PROGRAM hash_test

A nice addition would be add an index to the hash table, allowing one to have several hash tables inside the one hash table module. Any call to a subroutine would then also require specifying which hash table one needs to change.

The source code for the module is given here:

MODULE hash
  IMPLICIT NONE
  PRIVATE

  PUBLIC :: hash_init
  PUBLIC :: hash_get
  PUBLIC :: hash_set
  PUBLIC :: hash_print

  INTEGER,               PARAMETER   :: CharLength = 128
  INTEGER,               PARAMETER   :: start_hash_size = 50 
  INTEGER                            :: current_size, new_size
  CHARACTER(CharLength), ALLOCATABLE :: keys(:)
  REAL,                  ALLOCATABLE :: values(:)
  LOGICAL,               ALLOCATABLE :: used(:)
  INTEGER                            :: hash_index

CONTAINS

  SUBROUTINE hash_init
    INTEGER              :: status
    ALLOCATE(keys(start_hash_size), stat=status)
    ALLOCATE(values(start_hash_size), stat=status)
    ALLOCATE(used(start_hash_size), stat=status)
    hash_index = 0 
    keys(:) = ""
    values = 0.0
    used(:) = .FALSE.
    current_size = start_hash_size
  END SUBROUTINE hash_init

  SUBROUTINE hash_push(key, value)
    CHARACTER(*), INTENT(IN)     :: key
    REAL        , INTENT(IN)     :: value
    hash_index = hash_index + 1
    IF(hash_index > Size(keys, 1)) CALL hash_reallocate
    keys(hash_index) = key
    values(hash_index) = value
    used(hash_index) = .TRUE.
  END SUBROUTINE hash_push

  SUBROUTINE hash_set(key, value)
    CHARACTER(*), INTENT(IN)     :: key
    REAL        , INTENT(IN)     :: value
    INTEGER                      :: local_index
    LOGICAL                      :: found
    found = .FALSE. 
    DO local_index = 1,Size(keys,1)
      IF(TRIM(keys(local_index)) == TRIM(key)) THEN 
        values(local_index) = value
        found = .TRUE.
      ENDIF
    ENDDO 
    IF(.NOT.found) THEN
      CALL hash_push(key, value)
    ENDIF 
  END SUBROUTINE hash_set

  SUBROUTINE hash_get(key, value)
    CHARACTER(*), INTENT(IN)     :: key
    REAL        , INTENT(OUT)    :: value
    INTEGER                      :: local_index
    LOGICAL                      :: found
    found = .FALSE. 
    DO local_index = 1,Size(keys,1)
      IF(TRIM(keys(local_index)) == TRIM(key)) THEN 
        value = values(local_index)
        found = .TRUE.
      ENDIF
    ENDDO 
    IF(.NOT.found) CALL print_error("Unknown key")
  END SUBROUTINE hash_get

  SUBROUTINE hash_print
    INTEGER  :: local_index 
    PRINT*, "Contents of the hashtable:"
    DO local_index = 1,Size(keys,1)
      IF(used(local_index)) PRINT*, TRIM(keys(local_index)), " = ", values(local_index)
    ENDDO
  END SUBROUTINE hash_print

  SUBROUTINE hash_reallocate
    CHARACTER(CharLength), ALLOCATABLE :: temp_keys(:)
    REAL                 , ALLOCATABLE :: temp_values(:)   
    LOGICAL              , ALLOCATABLE :: temp_used(:)
    INTEGER                            :: status
    new_size = current_size + start_hash_size
    ALLOCATE(temp_keys(current_size))
    ALLOCATE(temp_values(current_size))
    ALLOCATE(temp_used(current_size))
    temp_keys(:) = keys
    temp_values(:) = values(:)
    temp_used(:) = used(:)
    DEALLOCATE(keys)
    DEALLOCATE(values)
    DEALLOCATE(used)
    ALLOCATE(keys(new_size))
    keys(:) = ""
    ALLOCATE(values(new_size))
    values(:) = 0.0
    ALLOCATE(used(new_size))
    used(:) = .FALSE.
    keys(1:current_size) = temp_keys(:)
    values(1:current_size) = temp_values(:)
    used(1:current_size) = temp_used(:)
  END SUBROUTINE hash_reallocate

  SUBROUTINE print_error(text)
    CHARACTER(*) :: text
    PRINT*, text
    STOP
  END SUBROUTINE print_error
END MODULE hash

• hash_init(no_items), initializes the hash table with the correct number of key-value pairs.
• hash_push(key, value), pushes the key-value pair to the next available place in the hash table, i.e. first index 1, next index 2, etc.
• hash_get(key, value), retrieves the value for a given key. Errors are raised when the hash table is not yet fully filled, or when the key has not been found.
• hash_set(key, value), allows the user to change the value of a given key-value pair. Errors are raised when the hash table is not yet fully filled, or when the key has not been found.
• hash_print(), prints the current contents of the hash table to the screen.

The following program illustrates the use of the hash module (tested using ifort and gfortran):

PROGRAM hash_test
  use hash
  REAL :: res = 0.0

  CALL hash_init(3)

  CALL hash_push("one", 1.0)
  CALL hash_push("two", 2.0)
  CALL hash_push("three", 3.0)

  CALL hash_print
  CALL hash_get("one", res)
  PRINT*, res
  CALL hash_get("two", res)
  PRINT*, res

  CALL hash_set("one", 60.0)

  CALL hash_print
  CALL hash_get("one", res)
  PRINT*, res
END PROGRAM hash_test

The code of the module hash is given here:

MODULE hash
  IMPLICIT NONE
  PRIVATE

  PUBLIC :: hash_init
  PUBLIC :: hash_push
  PUBLIC :: hash_get
  PUBLIC :: hash_set
  PUBLIC :: hash_print

  INTEGER,               PARAMETER   :: CharLength = 128
  CHARACTER(CharLength), ALLOCATABLE :: keys(:)
  REAL,                  ALLOCATABLE :: values(:)
  INTEGER                            :: hash_index

CONTAINS

  SUBROUTINE hash_init(no_items)
    INTEGER, INTENT(in)  :: no_items
    INTEGER              :: status
    ALLOCATE(keys(no_items), stat=status)
    ALLOCATE(values(no_items), stat=status)
    hash_index = 0 
  END SUBROUTINE hash_init

  SUBROUTINE hash_push(key, value)
    CHARACTER(*), INTENT(IN)     :: key
    REAL        , INTENT(IN)     :: value
    hash_index = hash_index + 1
    IF(hash_index > Size(keys, 1)) CALL print_error("Error: Hash table is already full")
    keys(hash_index) = key
    values(hash_index) = value
  END SUBROUTINE hash_push

  SUBROUTINE hash_set(key, value)
    CHARACTER(*), INTENT(IN)     :: key
    REAL        , INTENT(IN)     :: value
    INTEGER                      :: local_index
    LOGICAL                      :: found
    found = .FALSE. 
    IF(hash_index < Size(keys, 1)) CALL print_error("Error: the hashtable is not yet full") 
    DO local_index = 1,Size(keys,1)
      IF(TRIM(keys(local_index)) == TRIM(key)) THEN 
        values(local_index) = value
        found = .TRUE.
      ENDIF
    ENDDO 
    IF(.NOT.found) CALL print_error("Unknown key")
  END SUBROUTINE hash_set

  SUBROUTINE hash_get(key, value)
    CHARACTER(*), INTENT(IN)     :: key
    REAL        , INTENT(OUT)    :: value
    INTEGER                      :: local_index
    LOGICAL                      :: found
    found = .FALSE. 
    IF(hash_index < Size(keys, 1)) CALL print_error("Error: the hashtable is not yet full") 
    DO local_index = 1,Size(keys,1)
      IF(TRIM(keys(local_index)) == TRIM(key)) THEN 
        value = values(local_index)
        found = .TRUE.
      ENDIF
    ENDDO 
    IF(.NOT.found) CALL print_error("Unknown key")
  END SUBROUTINE hash_get

  SUBROUTINE hash_print
    INTEGER  :: local_index 
    PRINT*, "Contents of the hashtable:"
    DO local_index = 1,Size(keys,1)
      PRINT*, TRIM(keys(local_index)), " = ", values(local_index)
    ENDDO
  END SUBROUTINE hash_print

  SUBROUTINE print_error(text)
    CHARACTER(*) :: text
    PRINT*, text
    STOP
  END SUBROUTINE print_error
END MODULE hash