NIMBioS - User contributions [en]

Rocky R Prime

2026-01-08T14:17:28Z

Gderrybe: Update R module to latest version

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSEQ()

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c ) %do% {
if(any((check_i %% known_primes )==0 ) ) return(numeric())
return(c(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt",
row.names = F,col.names = F)
</pre>

=== R parallel script ===
Naive version
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c ) %dopar% {
if(any((check_i %% known_primes )==0 ) ) return(numeric())
return(c(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel.txt",
row.names = F,col.names = F)
</pre>
Only check numbers ending in 1, 3, 7 and 9
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- rep(3:99, each=4)*10 + rep(c(1,3,7,9), 97)

found_primes <- foreach(check_i= search_space, .combine=c ) %dopar% {
if(any((check_i %% known_primes )==0 ) ) return(numeric())
return(c(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel_fast.txt",
row.names = F,col.names = F)
</pre>

=== Slurm submission script ===
<pre>
#!/bin/bash
#SBATCH --job-name=R_PRIME ### Job Name
#SBATCH --output=R_prime_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --nodes=1 ### Node count required for the job
#SBATCH --ntasks-per-node=1 ### Number of tasks to be launched per Node
#SBATCH --mem-per-cpu=2G

#SBATCH --cpus-per-task=40

module load R-bundle-CRAN/2025.10-foss-2025a
date
R --version

time Rscript R_prime_serial.R
date
time Rscript R_prime_parallel.R
date
time Rscript R_prime_parallel_fast.R
date
</pre>

== Running the Prime Number example ==
=== Uploading the code ===
The simple way to see this code is to clone the github repository:

<pre>
[[ -e ~/git ]] || mkdir ~/git # Auto-create git subdirectory
cd ~/git # switch to git subdirectory
[[ -e r-prime-cluster ]] || git clone git@github.com:rocky-cluster/r-prime-cluster.git
cd r-prime-cluster
</pre>

Sanity check:
<pre>
cat BLAH

</pre>

=== Submitting the script ===
<pre>
sbatch R-prime.srun
</pre>

=== Looking at the results ===
Check the job queue, wait for job completion

<pre>
squeue
</pre>

Check log file:
<pre>
ls -l R_prime_*.out

# just look at the latest output log
cat $( ls -t R_prime_*.out | head -n 1)
</pre>

Check results file:
<pre>
# Quick hash check verifying prime number sets are identical
md5sum $( ls -t R_prime_*.txt | head -n 3)
</pre>

Rocky R HelloWorld

2026-01-08T14:15:26Z

Gderrybe: Update R module to latest version

= R Code =

'''helloworld.R'''
<pre>
print("Hello World!")
</pre>

= Batch Script =

'''helloworld.run'''
<pre>
#!/bin/bash

#SBATCH --job-name=R_HELLOWORLD
#SBATCH --output=R_hello_%j.out

module load R-bundle-CRAN/2025.10-foss-2025a

Rscript helloworld.R
</pre>

= Running Job =

<pre>
[test_user@rocky7 helloworld]$ pwd
/home/test_user/projects/R/helloworld
</pre>
<pre>
[test_user@rocky7 helloworld]$ ls
helloworld.R helloworld.run
</pre>
<pre>
[test_user@rocky7 helloworld]$ sbatch helloworld.run
Submitted batch job 3875
</pre>
<pre>
[test_user@rocky7 helloworld]$ ls
helloworld.py helloworld.run R_hell0_3875.out
</pre>
<pre>
[test_user@rocky7 helloworld]$ cat R_hell0_3875.out
Hello World!
</pre>

Rocky R package

2026-01-08T14:00:30Z

Gderrybe: Update R module to latest CRAN bundle

= About =

The R modules on Rocky have many packages pre-loaded but not all of them. We are able to install our own packages locally in our home directory.

= Installing =

First we load the R module we want to use. For our example, we're going to use R-bundle-CRAN/2025.10-foss-2025a.

<pre>
module load R-bundle-CRAN/2025.10-foss-2025a
</pre>

Next we decide on a location for the R packages to be installed, make that directory, and then set the R_LIBS_USER environment variable to point to the new location. Here we use the name of the module as the package directory name since each version will need it's own packages installed separately.

<pre>
mkdir -p ~/R-bundle-CRAN/2025.10-foss-2025a
export R_LIBS_USER="$HOME/R-bundle-CRAN/2025.10-foss-2025a"
</pre>

Now we start R and install the package. If we have not set a mirror, it will ask for us to choose one.
<pre>
R
install.packages('adespatial')
</pre>

= Using =

In our batch file for our job, we load the R module and set the R_LIBS_USER environment variable so that our job can find our installed packages.

'''spatial_test.sh'''
<pre>
#!/bin/bash

#SBATCH --job-name=SPATIAL_TEST
#SBATCH --output=R_spatial_%j.out

module load R-bundle-CRAN/2025.10-foss-2025a
export R_LIBS_USER="$HOME/R-bundle-CRAN/2025.10-foss-2025a"

Rscript spatial.R
</pre>

We run the job just like any other Rocky job by using the sbatch command.

<pre>
sbatch spatial_test.sh
</pre>

Rocky R HelloWorld

2023-04-20T18:34:46Z

Gderrybe:

= R Code =

'''helloworld.R'''
<pre>
print("Hello World!")
</pre>

= Batch Script =

'''helloworld.run'''
<pre>
#SBATCH --job-name=R_HELLOWORLD
#SBATCH --output=R_hello_%j.out

module load R/4.2.1-foss-2022a

Rscript helloworld.R
</pre>

= Running Job =

<pre>
[test_user@rocky7 helloworld]$ pwd
/home/test_user/projects/R/helloworld
</pre>
<pre>
[test_user@rocky7 helloworld]$ ls
helloworld.R helloworld.run
</pre>
<pre>
[test_user@rocky7 helloworld]$ sbatch helloworld.run
Submitted batch job 3875
</pre>
<pre>
[test_user@rocky7 helloworld]$ ls
helloworld.py helloworld.run R_hell0_3875.out
</pre>
<pre>
[test_user@rocky7 helloworld]$ cat R_hell0_3875.out
Hello World!
</pre>

Rocky R Prime

2023-04-10T17:54:55Z

Gderrybe: /* R parallel script */

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSEQ()

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c ) %do% {
if(any((check_i %% known_primes )==0 ) ) return(numeric())
return(c(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt",
row.names = F,col.names = F)
</pre>

=== R parallel script ===
Naive version
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c ) %dopar% {
if(any((check_i %% known_primes )==0 ) ) return(numeric())
return(c(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel.txt",
row.names = F,col.names = F)
</pre>
Only check numbers ending in 1, 3, 7 and 9
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- rep(3:99, each=4)*10 + rep(c(1,3,7,9), 97)

found_primes <- foreach(check_i= search_space, .combine=c ) %dopar% {
if(any((check_i %% known_primes )==0 ) ) return(numeric())
return(c(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel_fast.txt",
row.names = F,col.names = F)
</pre>

=== Slurm submission script ===
<pre>
#!/bin/bash
#SBATCH --job-name=R_PRIME ### Job Name
#SBATCH --output=R_prime_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --nodes=1 ### Node count required for the job
#SBATCH --ntasks-per-node=1 ### Number of tasks to be launched per Node
#SBATCH --mem-per-cpu=2G

#SBATCH --cpus-per-task=40

module load R/4.2.1-foss-2022a
date
R --version

time Rscript R_prime_serial.R
date
time Rscript R_prime_parallel.R
date
time Rscript R_prime_parallel_fast.R
date
</pre>

== Running the Prime Number example ==
=== Uploading the code ===
The simple way to see this code is to clone the github repository:

<pre>
[[ -e ~/git ]] || mkdir ~/git # Auto-create git subdirectory
cd ~/git # switch to git subdirectory
[[ -e r-prime-cluster ]] || git clone git@github.com:rocky-cluster/r-prime-cluster.git
cd r-prime-cluster
</pre>

Sanity check:
<pre>
cat BLAH

</pre>

=== Submitting the script ===
<pre>
sbatch R-prime.srun
</pre>

=== Looking at the results ===
Check the job queue, wait for job completion

<pre>
squeue
</pre>

Check log file:
<pre>
ls -l R_prime_*.out

# just look at the latest output log
cat $( ls -t R_prime_*.out | head -n 1)
</pre>

Check results file:
<pre>
# Quick hash check verifying prime number sets are identical
md5sum $( ls -t R_prime_*.txt | head -n 3)
</pre>

Rocky R Prime

2023-04-10T17:53:15Z

Gderrybe: /* R serial script */

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSEQ()

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c ) %do% {
if(any((check_i %% known_primes )==0 ) ) return(numeric())
return(c(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt",
row.names = F,col.names = F)
</pre>

=== R parallel script ===
Naive version
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c() ) %dopar% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel.txt")

</pre>
Only check numbers ending in 1, 3, 7 and 9
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- rep(3:99, each=4)*10 + rep(c(1,3,7,9), 97)

found_primes <- foreach(check_i= search_space, .combine=c() ) %dopar% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel_fast.txt")

</pre>

=== Slurm submission script ===
<pre>
#!/bin/bash
#SBATCH --job-name=R_PRIME ### Job Name
#SBATCH --output=R_prime_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --nodes=1 ### Node count required for the job
#SBATCH --ntasks-per-node=1 ### Number of tasks to be launched per Node
#SBATCH --mem-per-cpu=2G

#SBATCH --cpus-per-task=40

module load R/4.2.1-foss-2022a
date
R --version

time Rscript R_prime_serial.R
date
time Rscript R_prime_parallel.R
date
time Rscript R_prime_parallel_fast.R
date
</pre>

== Running the Prime Number example ==
=== Uploading the code ===
The simple way to see this code is to clone the github repository:

<pre>
[[ -e ~/git ]] || mkdir ~/git # Auto-create git subdirectory
cd ~/git # switch to git subdirectory
[[ -e r-prime-cluster ]] || git clone git@github.com:rocky-cluster/r-prime-cluster.git
cd r-prime-cluster
</pre>

Sanity check:
<pre>
cat BLAH

</pre>

=== Submitting the script ===
<pre>
sbatch R-prime.srun
</pre>

=== Looking at the results ===
Check the job queue, wait for job completion

<pre>
squeue
</pre>

Check log file:
<pre>
ls -l R_prime_*.out

# just look at the latest output log
cat $( ls -t R_prime_*.out | head -n 1)
</pre>

Check results file:
<pre>
# Quick hash check verifying prime number sets are identical
md5sum $( ls -t R_prime_*.txt | head -n 3)
</pre>

Rocky R Prime

2023-04-10T17:20:50Z

Gderrybe: Add repo URL

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSeq()

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c() ) %do% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt")

</pre>

=== R parallel script ===
Naive version
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c() ) %dopar% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel.txt")

</pre>
Only check numbers ending in 1, 3, 7 and 9
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- rep(3:99, each=4)*10 + rep(c(1,3,7,9), 97)

found_primes <- foreach(check_i= search_space, .combine=c() ) %dopar% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_parallel_fast.txt")

</pre>

=== Slurm submission script ===
<pre>
#!/bin/bash
#SBATCH --job-name=R_PRIME ### Job Name
#SBATCH --output=R_prime_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --nodes=1 ### Node count required for the job
#SBATCH --ntasks-per-node=1 ### Number of tasks to be launched per Node
#SBATCH --mem-per-cpu=2G

#SBATCH --cpus-per-task=40

module load R/4.2.1-foss-2022a
date
R --version

time Rscript R_prime_serial.R
date
time Rscript R_prime_parallel.R
date
time Rscript R_prime_parallel_fast.R
date
</pre>

== Running the Prime Number example ==
=== Uploading the code ===
The simple way to see this code is to clone the github repository:

<pre>
[[ -e ~/git ]] || mkdir ~/git # Auto-create git subdirectory
cd ~/git # switch to git subdirectory
[[ -e r-prime-cluster ]] || git clone git@github.com:rocky-cluster/r-prime-cluster.git
cd r-prime-cluster
</pre>

Sanity check:
<pre>
cat BLAH

</pre>

=== Submitting the script ===
<pre>
sbatch R-prime.srun
</pre>

=== Looking at the results ===
Check the job queue, wait for job completion

<pre>
squeue
</pre>

Check log file:
<pre>
ls -l R_prime_*.out

# just look at the latest output log
cat $( ls -t R_prime_*.out | head -n 1)
</pre>

Check results file:
<pre>
# Quick hash check verifying prime number sets are identical
md5sum $( ls -t R_prime_*.txt | head -n 3)
</pre>

Rocky R Prime

2023-04-06T20:23:39Z

Gderrybe:

Insert example here

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSeq()

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c() ) %do% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt")

</pre>

=== R parallel script ===
Naive version
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c() ) %dopar% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt")

</pre>
Only check numbers ending in 1, 3, 7 and 9
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- rep(3:99, each=4)*10 + rep(c(1,3,7,9), 97)

found_primes <- foreach(check_i= search_space, .combine=c() ) %dopar% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt")

</pre>

=== Slurm submission script ===
<pre>
#!/bin/bash
#SBATCH --job-name=R_PRIME ### Job Name
#SBATCH --output=R_prime_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --nodes=1 ### Node count required for the job
#SBATCH --ntasks-per-node=1 ### Number of tasks to be launched per Node
#SBATCH --mem-per-cpu=2G

#SBATCH --cpus-per-task=40

module load R/4.2.1-foss-2022a
date
R --version

time Rscript R_prime_serial.R
date
time Rscript R_prime_parallel.R
date
time Rscript R_prime_parallel_fast.R
date
</pre>

== Running the Prime Number example ==
=== Uploading the code ===
The simple way to see this code is to clone the github repository:

<pre>
[[ -e ~/git ]] || mkdir ~/git # Auto-create git subdirectory
cd ~/git # switch to git subdirectory
[[ -e r_prime_cluster ]] || git clone #GITHUB REPO URL
cd r_prime_cluster
</pre>

Sanity check:
<pre>
cat BLAH

</pre>

=== Submitting the script ===
<pre>
sbatch R-prime.srun
</pre>

=== Looking at the results ===
Check the job queue, wait for job completion

<pre>
squeue
</pre>

Check log file:
<pre>
ls -l R_prime_*.out

# just look at the latest output log
cat $( ls -t R_prime_*.out | head -n 1)
</pre>

Check results file:
<pre>
# Quick hash check verifying prime number sets are identical
md5sum $( ls -t R_prime_*.txt | head -n 3)
</pre>

Rocky R Prime

2023-04-06T20:21:04Z

Gderrybe: /* R serial script */

Insert example here

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSeq()

known_primes <-
c(2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31)

search_space <- 34:999

found_primes <- foreach(check_i= search_space, .combine=c() ) %do% {
if(any((check_i %% known_primes )==0 ) return(list())
return(list(check_i))
}

write.table(sort(c(known_primes, found_primes)), file="R_prime_serial.txt")

</pre>

=== R parallel script ===
Naive version
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

</pre>
Only check numbers ending in 1, 3, 7 and 9
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

</pre>

=== Slurm submission script ===
<pre>
#!/bin/bash
#SBATCH --job-name=R_PRIME ### Job Name
#SBATCH --output=R_prime_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --nodes=1 ### Node count required for the job
#SBATCH --ntasks-per-node=1 ### Number of tasks to be launched per Node
#SBATCH --mem-per-cpu=2G

#SBATCH --cpus-per-task=40

module load R/4.2.1-foss-2022a
date
R --version

time Rscript R_prime_serial.R
date
time Rscript R_prime_parallel.R
date
time Rscript R_prime_parallel_fast.R
date
</pre>

== Running the Prime Number example ==
=== Uploading the code ===
The simple way to see this code is to clone the github repository:

<pre>
[[ -e ~/git ]] || mkdir ~/git # Auto-create git subdirectory
cd ~/git # switch to git subdirectory
[[ -e r_prime_cluster ]] || git clone #GITHUB REPO URL
cd r_prime_cluster
</pre>

Sanity check:
<pre>
cat BLAH

</pre>

=== Submitting the script ===
<pre>
sbatch R-prime.srun
</pre>

=== Looking at the results ===
Check the job queue, wait for job completion

<pre>
squeue
</pre>

Check log file:
<pre>
ls -l R_prime_*.out

# just look at the latest output log
cat $( ls -t R_prime_*.out | head -n 1)
</pre>

Check results file:
<pre>
# Quick hash check verifying prime number sets are identical
md5sum $( ls -t R_prime_*.txt | head -n 3)
</pre>

Rocky R Prime

2023-04-06T20:12:35Z

Gderrybe: /* Looking at the results */

Insert example here

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSeq()

library(doParallel)

registerDoParallel(40)

</pre>

=== R parallel script ===
Naive version
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

</pre>
Only check numbers ending in 1, 3, 7 and 9
<pre>
library(foreach)
library(doParallel)

registerDoParallel(40)

</pre>

=== Slurm submission script ===
<pre>
#!/bin/bash
#SBATCH --job-name=R_PRIME ### Job Name
#SBATCH --output=R_prime_%j.out ### File in which to store job output
#SBATCH --time=00:10:00 ### Wall clock time limit in Days-HH:MM:SS
#SBATCH --nodes=1 ### Node count required for the job
#SBATCH --ntasks-per-node=1 ### Number of tasks to be launched per Node
#SBATCH --mem-per-cpu=2G

#SBATCH --cpus-per-task=40

module load R/4.2.1-foss-2022a
date
R --version

time Rscript R_prime_serial.R
date
time Rscript R_prime_parallel.R
date
time Rscript R_prime_parallel_fast.R
date
</pre>

== Running the Prime Number example ==
=== Uploading the code ===
The simple way to see this code is to clone the github repository:

<pre>
[[ -e ~/git ]] || mkdir ~/git # Auto-create git subdirectory
cd ~/git # switch to git subdirectory
[[ -e r_prime_cluster ]] || git clone #GITHUB REPO URL
cd r_prime_cluster
</pre>

Sanity check:
<pre>
cat BLAH

</pre>

=== Submitting the script ===
<pre>
sbatch R-prime.srun
</pre>

=== Looking at the results ===
Check the job queue, wait for job completion

<pre>
squeue
</pre>

Check log file:
<pre>
ls -l R_prime_*.out

# just look at the latest output log
cat $( ls -t R_prime_*.out | head -n 1)
</pre>

Check results file:
<pre>
# Quick hash check verifying prime number sets are identical
md5sum $( ls -t R_prime_*.txt | head -n 3)
</pre>

Rocky R Prime

2023-04-06T20:06:33Z

Gderrybe: /* Submitting the script */

Rocky R Prime

2023-04-06T20:05:40Z

Gderrybe: /* Uploading the code */

Rocky R Prime

2023-04-06T19:56:18Z

Gderrybe: /* R parallel script */

Rocky R Prime

2023-04-06T19:54:25Z

Gderrybe: /* Slurm submission script */

Rocky R Prime

2023-04-06T19:45:20Z

Gderrybe: /* R parallel script */

Rocky R Prime

2023-04-06T19:45:07Z

Gderrybe: /* R serial script */

Insert example here

== Prime Number example code ==

=== R serial script ===
<pre>
library(foreach)
registerDoSeq()

library(doParallel)

registerDoParallel(40)

</pre>

=== R parallel script ===
Code

=== Slurm submission script ===
Code

== Running the Prime Number example ==
=== Uploading the code ===

=== Submitting the script ===

=== Looking at the results ===

Rocky R Prime

2023-04-06T19:38:25Z

Gderrybe: Example for Running R Scripts on Rocky

Insert example here

== Prime Number example code ==

=== R serial script ===
Code

=== R parallel script ===
Code

=== Slurm submission script ===
Code

== Running the Prime Number example ==
=== Uploading the code ===

=== Submitting the script ===

=== Looking at the results ===