We represent the number of pairs of rabbits on month n with the function fib(n).

This function has the following rules:

• fib(0) = 0
• fib(1) = 1
• fib(n) = fib(n-1) + fib(n-2)

Your task is to write a recursive function in R that has input n and output fib(n).

Recursive means that the function calls itself

It is like the factorial example

facto <- function(n) {
    if(n <= 1) {
        ans <- 1
    } else {
        m <- n-1
        ans <- n * facto(m)
    }
    return(ans)
}

• The name changes from facto into fib
• There are two exit conditions
  • fib(0) = 0 means if(n==0) {ans <- 0}
  • fib(1) = 1 means if(n==1) {ans <- 1}

# author: I CAN NOT DO THİS
fib <- function(n) {
  if(n==0) {
  ans <- 0
  if(n==1) {
    ans <- 1
} else {
ans <- fib(n-1) + fib(n-2)
}
return(ans)
}

fib <- function(n) {
    if(n==0) {
        ans <- 0
    }
    if(n==1) {
        ans <- 1
    } else {
        ans <- fib(n-1) + fib(n-2)
    }
    return(ans)
}

Use the debugger to see what happens when n is 0

(use h key)

fib <- function(n) {
  if(n <= 0){
    ans <- 0
  } else if(n <= 1) {
    ans <- 1
  } else {
    ans <- fib(n-1) + fib(n-2)
  }
  return(ans)
}

(use h key)

• This: n<=0 is a comparison. Result is logic

• This: n<-0 is an assignment. Result is numeric

• This: n==0 is a comparison. Result is logic

• This: n=0 is an assignment. Result is numeric

The cases n==0 and n==1 can be put together

fib <- function(n) {
  if(n <= 1){
    ans <- n
  } else {
    ans <- fib(n-1) + fib(n-2)
  }
  return(ans)
}

This is optional, but nice

(use h key)

You should always start with the easy parts

The easy part may not be the first part

We receive the turtle pointing in the arm direction

We must leave the turtle in the same place and same angle

draw_arm <- function(size) {
    turtle_forward(size)
    turtle_backward(size)
}

Notice that to undo something you have to undo each part in reverse order

You put your socks first, then your shoes

To undo you first “un-put” your shoes, then your socks

In general

\[Undo(A,B,C) = Undo(C), Undo(B), Undo(A)\]

Candidatus Carsonella ruddii is a obligate symbiont of Pachpsylla venusta.

There is much controversy over whether this is a living cell or simply an organelle as it is missing genes needed for living independently.

Published as “The 160-kilobase genome of the bacterial endosymbiont Carsonella.” https://www.ncbi.nlm.nih.gov/pubmed/17038615

ATGAATACTATATTTTCAAGAATAACACCATTAGGAAATGGTACGTTATGTGTTATAAGAATTTCTGGAA
AAAATGTAAAATTTTTAATACAAAAAATTGTAAAAAAAAATATAAAAGAAAAAATAGCTACTTTTTCTAA
ATTATTTTTAGATAAAGAATGTGTAGATTATGCAATGATTATTTTTTTTAAAAAACCAAATACGTTCACT
GGAGAAGATATAATCGAATTTCATATTCACAATAATGAAACTATTGTAAAAAAAATAATTAATTATTTAT
TATTAAATAAAGCAAGATTTGCAAAAGCTGGCGAATTTTTAGAAAGACGATATTTAAATGGAAAAATTTC
TTTAATAGAATGCGAATTAATAAATAATAAAATTTTATATGATAATGAAAATATGTTTCAATTAACAAAA
AATTCTGAAAAAAAAATATTTTTATGTATAATTAAAAATTTAAAATTTAAAATAAATTCTTTAATAATTT
GTATTGAAATCGCAAATTTTAATTTTAGTTTTTTTTTTTTTAATGATTTTTTATTTATAAAATATACATT
TAAAAAACTATTAAAACTTTTAAAAATATTAATTGATAAAATAACTGTTATAAATTATTTAAAAAAGAAT
TTCACAATAATGATATTAGGTAGAAGAAATGTAGGAAAGTCTACTTTATTTAATAAAATATGTGCACAAT
ATGACTCGATTGTAACTAATATTCCTGGTACTACAAAAAATATTATATCAAAAAAAATAAAAATTTTATC
TAAAAAAATAAAAATGATGGATACAGCAGGATTAAAAATTAGAACTAAAAATTTAATTGAAAAAATTGGA
ATTATTAAAAATATAAATAAAATTTATCAAGGAAATTTAATTTTGTATATGATTGATAAATTTAATATTA
AAAATATATTTTTTAACATTCCAATAGATTTTATTGATAAAATTAAATTAAATGAATTAATAATTTTAGT
TAACAAATCAGATATTTTAGGAAAAGAAGAAGGAGTTTTTAAAATAAAAAATATATTAATAATTTTAATT
TCTTCTAAAAATGGAACTTTTATAAAAAATTTAAAATGTTTTATTAATAAAATCGTTGATAATAAAGATT
TTTCTAAAAATAATTATTCTGATGTTAAAATTCTATTTAATAAATTTTCTTTTTTTTATAAAGAATTTTC
ATGTAACTATGATTTAGTGTTATCAAAATTAATTGATTTTCAAAAAAATATATTTAAATTAACAGGAAAT
TTTACTAATAAAAAAATAATAAATTCTTGTTTTAGAAATTTTTGTATTGGTAAATGAATATTTTTAATAT
AATTATTATTGGAGCAGGACATTCTGGTATAGAAGCAGCTATATCTGCATCTAAAATATGTAATAAAATA

• For each nucleotide
  • if the nucleotide is A, turtle moves left
  • if the nucleotide is T, turtle moves right
  • if the nucleotide is G, turtle moves up
  • if the nucleotide is C, turtle moves down

Despite being large molecules, DNA and proteins are made with pieces of only a few types

DNA is made of four bases. We can represent it with four letters

AGCTTTTCATTCTGACTGCAACGGGCAATATGTCTCTGTGTGGATTAAAAAAAGAGTGTCTGATAGCAGC

Proteins have 20 aminoacids and three stop codons. We can represent them with 23 letters.

MKRISTTITTTITITTGNGAG

In molecular biology we often work with sequences

• DNA sequences use 4 letters to represent the nucleotides in one of the two strands
• Protein sequences use 20 letters to represent the amino-acids, from amino to carboxyl terminal
• Other sequences are sometime used:
  • RNA,
  • DNA with ambiguous nucleotides,
  • amino-acid sequences with stop codons

The main reason why computing is useful for molecular biology

• DNA is discrete data
• Either “A”, “C”, “G” or “T”
• No middle-values
• All other things we measure are in a range
  • Like temperature, concentration, expression
• We can forget all the chemistry and work with symbols

There are several ways to store DNA or protein data

Most of the times they are stored in FASTA format

FASTA files are text files, with some rules

You should never use word to store sequences

To handle sequence data in R, we use the seqinr library

You have to install it once.

install.packages("seqinr")

Then you have to load it on every session

library(seqinr)