Let’s begin with a matrix as the object we will pass to a function, say:

m = [0 1 1 0 1; 1 0 0 1 0; 1 0 0 1 0; 0 1 1 0 0; 1 0 0 0 0]
new_m = m[:,:] # make a copy of the original matrix
new_m

This will return the following matrix:

5×5 Matrix{Int64}:
 0  1  1  0  1
 1  0  0  1  0
 1  0  0  1  0
 0  1  1  0  0
 1  0  0  0  0

Assume we pass this matrix to a function to work with it

function update_m(x)
    len = size(x)[1];
    x = ones(Int, len, len);
end

update_m(new_m)
new_m

update_m() passes the matrix on to the x argument. Inside the function, we create a new matrix, which we then assign to x. The function ends with nothing being returned. When we now take a look at our original matrix we see:

5×5 Matrix{Int64}:
 0  1  1  0  1
 1  0  0  1  0
 1  0  0  1  0
 0  1  1  0  0
 1  0  0  0  0

that nothing has changed.

But what happens when, instead of assigning a new value to x, we change x by indexing it with [:]?

function update_m_mutate(x)
    len = size(x)[1];
    x[:] = ones(Int, len, len);
end

update_m_mutate(new_m)
new_m

5×5 Matrix{Int64}:
 1  1  1  1  1
 1  1  1  1  1
 1  1  1  1  1
 1  1  1  1  1
 1  1  1  1  1

Now, we find that the original Array to which new_m pointed has been changed, according to the changes made inside the function.

The is because Julia passes arguments by sharing them. Instead of creating a copy specifically for the use inside the function, Julia simply points to the same object. This binding will only be broken, when there is a new assignment to the argument (as we have seen above with x = ones(Int, len, len)) but not if we make changes to the object.

This behaviour is also well documented in Julia’s manual right here, and discussed here.

One big advantage (in case you are not changing the original argument) is that your computer does not have to create copies of objects that are only referenced, which will make code execution a lot more efficient.

It is just important to keep this behaviour in mind.

What we can learn from others, such as skills that help us to cope with our environment, is largely determined by who we interact with. For example, larger and more dense social networks, where each individual interacts with many other individuals, are known to spread new behaviours or information faster and further than sparse networks (Centola, 2010; Derex & Boyd, 2016). However, it is largely unknown whether the nature of what we need to learn to survive affects our social behaviour and ultimately the structure of the social network.

In this project, I develop an agent-based simulation model together with Erol Akçay to better understand the feedback between culture and network structure.

Read UPenn’s official press release or the aricle in Science Advances.

The Julilang website kind of already gives you the answer here. But it still took me a while to figure our exactly what to do. So, here we go.

1. Download the binaries from the Julialang website (in my case those were the Generic Linux Binaries for 64-bit architecture)

2. Upload this .tar file to your user folder on the cluster, e.g. /home/yourusername/bin

3. Untar the file using: tar -xvf

4. Change the folder name to something more useful (I just used the version number: julia062)

5. Now, we need to let the server know that it should this version of julia whenever we call julia from the terminal. To do this, we need to change the PATH variable; Have a look with echo $PATH (should look similar to this: /usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games); What we want to do, is to add our path /home/yourusername/bin to it. So, create a/or use the .profile file in your home directory (to get to the home directory, simply enter cd); with the command nano .profile a text editor opens; We want to add our path to the beginning of the PATH variable, so like in math we want the new PATH to be our PATH + oldPATH. To achieve this we will write: PATH="/home/yourusername/bin/julia062/bin:$PATH"; the $PATH simply adds whatever the PATH currently is to the end of our path. (You might have to replace /home/yourusername with $HOME, depending on the server settings). Finally, save the file by pressing Ctrl-X and accepting the changes.

6. Now, logout of the cluster and log in again.

7. When you now call julia, the version you just installed should be the one up and running. Remember, that you now also need to install all the packages you want to use for the updated version of Julia.

Enjoy your latest version of Julia!

Oh, and don’t forget to change the call in your source files as well. Those look usually like this #!/usr/bin/env julia but now needs to be #!/home/yourusername/bin/julia062/bin julia. Otherwise, you will only use the latest version of julia whenever you call it directly, but your jobs for the cluster would still run with the version installed globally.

Still questions? Let me know how to improve this post.

The first session started with Matthew Cobb (@matthewcobb), Susanne Shultz (@Susanne_Shultz) and Jeffrey Forshaw (@jrf1968) three successful scientists that presented a very interesting insight into their relations with public media and journalists.

It is not clear to me whether Jeffrey Forshaw, particle physicist at the University of Manchester, directed his comment ‘scientists are just ordinary people who are curious and want to understand’ towards the much younger scientists or the journalists in the room. However, he made the important point that it is necessary for every researcher to know its stuff. Only when you feel comfortable in your field you can freely talk about it. Also, never try to hide your work. The only way to counter prejudice against scientific work is to be pro-active. Don’t wait for the public to ask you what you do, just start to tell them. And let me add here: even when they don’t ask.

This point was also supported by Matthew Cobb, evolutionary biologist at the University of Manchester. Being pro-active is especially important when you work in controversial areas, like gene modification, medical research, or even evolutionary biology. Writing about your and others work is good for at least two reasons. For one, you train how to write. And the other, your field becomes more understandable by the public and thus less suspicious of doing ‘bad things’.

If you finished your work on a project with a great paper, let your press officer now. They are your best link to all kinds of media and they will also help you to make the points you intended. Susanne Shultz, like Cobb evolutionary biologist at the University of Manchester, recommends to write a press release. Looking towards the journalists, she mentions that it is a lot faster for them to copy-paste an article than to write one from scratch.It might also prevent misinterpretations.

‘I assume’, says Forshaw, ‘media gets it always wrong.’ Therefore, be careful what you say and how you say it. Never try to oversimplify your work, but also don’t oversell it conclude Cobb and Forshaw. And most importantly, never let journalists push you to make a specific comment or statement. Never be afraid to embrace the three simple words that form the foundation of science: ‘I don’t know’ (or if you prefer ‘We don’t know’).

The second session brought BBC journalist Victoria Gill (@Vic_Gill) and freelancing journalist David Derbyshire (@dderbyshire). Their description of their daily work added an interesting angle to the panel in the morning. As representatives of different media (online, telly, print) they are interested novelties and surprises. If you want a big story talk about something big, or as Derbyshire explains it, ‘Of course an elephant is more interesting than a cat, which is more interesting than a mouse, and so on.’

Both Gill and Derbyshire point out that you shouldn’t be afraid of contacting journalists. They know what makes a good story. They are the professional story tellers and are glad to work together with whoever has something interesting to offer. Whether they talk to a PhD student, who actually does the job, or to its professor doesn’t really matter for them. Both are equally unknown to them. ‘As long as they don’t try to take over the editorial part’, states Gill.

This was a very interesting and refreshingly different workshop. Many thanks to the organisers and all participants, especially the speakers that took their time and afford to share their experience.

Another blogger blogged about the event here.

Thanks to colleagues and users from around the world we received useful feedback to make the package even better. We fixed problems and added further functionality. We now decided that it is time to make the package available to a broader audience. We published at CRAN since it is the primary repository for R packages.

Now, it is possible to download and install the ‘move’ package from within R with:

install.packages("move")

We aim to add further functionalities to the package soon. We hope that the package will be useful for biologists in general and movement ecologists in specific.

Nowadays the MCP is scarcely if at all used to calculate home ranges. Kernel Density algorithms and Brownian Bridge Movement Models serve more sophisticated results. The results are much closer to the real observations. Nevertheless, the MCP calculation can still be used to compare own results with older studies.

The hrBootstrap() function in our move package works for Move and MoveStack objects (individuals or groups of individuals). We implemented here the mcp() and mcp.area() function from the adehabitatHR package [2]. We calculate for different number of random locations the mcp. For example for a set of 70 location fixes we calculate the mcp with 5, 6, 8, 10, 13, 16, 20, 25, 32, 40, 50, and 63 locations. Each step is repeated by default 100 times, each time with different locations. The returned data frame represents the calculated mcp area (you can specify the unit with the unout argument) for the according quantiles (0%, 25%, 50%, 75%, 100%) of the values.

By default the quantiles for the different number of locations are plotted as a line plot (see below).

The version will be available, as soon as the r-forge page is back online again.

References

[1] Minimum Conevx Polygon (MCP) http://www.stat.ufl.edu/STA6934/Minimum%20Convex%20Polygon%201%2017%2007.pdf

[2] Home Range Estimation in R: the adehabitatHR Package http://mirrors.fe.up.pt/CRAN/web/packages/adehabitatHR/vignettes/adehabitatHR.pdf

The function works with objects of the Raster class. This is an advantage over a similar function from the adehabitatHR package (getvolumeUD), which works with objects of the class estUD and estUDm, that are created for example by the kernelUD function from the same package. Allowing objects from the Raster class (raster package) makes the getVolumeUD more flexible.

Using:

new <- getVolumeUD(raster)
contour95 <- new<=0.

where new is the raster that is returned from getVolumeUD(), you calculate a new raster that has only 0 for cells that are outside the 95% contour and 1 for cells that are inside the 95% contour. It represents the 95% contour of the UD.

Two rasters with UD from the same record. Left: raw output from a DBBMM calculation (probabilities are between 0 and 0.03). Right: transformed raster (cells have now the values of the contour they belong to; values are between 0 and 1).

[A great thank you to Bart Kranstauber that provided the majority of the functions code.]

You find more about the move package on our lab page, or direct on r-forge.

Visit as well the Movebank site to see which studies are public available.

If you have the program RStudio and the R package knitr (just type in R install.packages(‘knitr’)) installed we we are ready to start.

1. Open RStudio and click on the new file icon

   

2. Select R Markdown to create a new Markdown

   

3. RStudio will now open a template file. It already has a title some text and so called R chunks, which include R code as you would usually have in your R files.
4. Add and change text and insert your R code (you can of course run the code in line or whole chunks). By the way, you find helpful information by clicking at the question mark icon in the top option bar of the source window (where you are currently entering your text). Click on Markdown Quick Reference to get an overview of useful commands. Click on Using R Markdown to get the full introduction from the RStudio website.
5. If you are satisfied with the text and the data save the file in a new folder (I recommend a folder because the knitting process ends usually with a .Rmd, .md, and .html file, and maybe more files, but see below).
6. Finally, click on Knit HTML to create your RMarkdown HTML file. The compiler will go through your text and your R chunks and create a Markdown file (.md) which it uses to return a HTML file.

Okay, let’s have a look how all these file may look like in the end. Copy and paste the following code in your source window and knit it to see what the result looks like.

The Gamma Distribution
========================================================
In _probability theory_ and statistics, the **gamma distribution** is a two-parameter family of continuous probability distributions.

The gamma distribution is described by a shape parameter $k$ and a scale parameter $\theta$. Its variance is $Var(X)=k*\theta^2$ and its mean is $E(X)=k*\theta$. The 'r 1+1'functions look like this in R:

```{r}
var_gamma <- function(k,t) return(k*(t^2))
mean_gamma <- function(k,t) return(k*t)

```

The next graph shows how the distribution changes with a chaging shape ($k$) value.

```{r, echo=FALSE, fig.width=10, fig.height=5}
plot(sort(rgamma(n=10000,shape=(K <- c(0.1,0.5,2,5,11)),scale=0.4)), type=‘l’, col=1, lwd=2, ylim=c(0,10), xlab=‘sorted values’, ylab=‘’)
for(k in K[-1]){
lines(sort(rgamma(n=10000,shape=k,scale=0.4)), lwd=2)
}

The resulting HTML file shout look like this:

It is a minimal example of what you can do. We have there: a title, words in italic and bold letters, and even inline LaTeX code (it is flanked by dollar signs, find possible LaTeX symbol code here). I also included (obviously obsolete but for proof of principle) in line R code. It starts with r and ends with . In-between you can write whatever R code you want. You might want to calculate the sum or the mean of a data column or maybe a mean in combination with the standard deviation. You can use the following to do this:

    ```{r}
    DF <- data.frame(first=runif(10,0,1), second=runif(10,1,2))
    DF
    ```
    The mean value of the first experiment is $'r mean(DF$first)' \pm 'r sd(DF$first)'$.

Awesome, you get your results in line without writing any number down. This means also, that this is a very useful tool if you have report that you have to write repeatedly and only the numbers change. Just update the raw data and the report changes itself the next time you knit it. (Note, I combined LaTeX and R in-line code in the above example, yes it is possible).

You may find, that next to the introducing {r} there are sometimes further attributes like {r setup, echo=FALSE, results='hide'}. This line for example means the following:

• the chunk is called “setup”
• the code that you entered is not ‘echoed’ in the final document
• and all results are ‘hide’ in the final document

You might use this combination when you for example just want to load some function into your file that no-one else should see. The code is still evaluated. If you have code that you don’t want to evaluate (maybe it takes a long time to calculate or you don’t care for it at the moment) just add eval=FALSE. During the knitting process this chunk will not be evaluated.

Similarly, if you have a chunk that you only want to calculate once and want R to remember the results use cache=TRUE. This will save the results in a folder called ‘cache’. Every chunk with the argument cache=TRUE will be saved individually. As long as you don’t change the code in the chunk R will not calculate it again.

If you think that some of the graphs that you created during knitting would fit perfectly in another document, just go to the folder that you created for this document. You will find there a folder called figure, which contains all figures that R created during knitting as png files.

Finally, once you finished polishing your file and you want share it with your supervisor or colleague, it is enough to send the HTML file. All images are part of this HTML file due to the so called URI Scheme.

Now, enjoy having all your code, text and results stored in one place.