DEV Community: Adam Spannbauer

Choosing between R and Python... by asking the languages themselves

Adam Spannbauer — Fri, 12 Oct 2018 00:28:43 +0000

There's been a lot of discussion over the years about R and Python in statistics/data science. Which language should you pick if you're starting out in data science? Which language is better at statistics? Which language is better for machine learning? Which language is better at ______?

Of course, some really awesome people have gone out of their way to try and help you answer these questions. For example, you can check out this infographic shared by Karlijn Willems on DataCamp. The analysis goes through many different categories and presents hard data for its readers. This post will do none of that.

Today we are going to ask the languages which of them is better. This should provide an easy answer for us to go by if they both agree on the winner.

Asking R

> 'R' > 'python'
[1] TRUE

Asking Python

>>> 'python' > 'R'
True

Well... looks like we're still in the same spot. There isn't a clear winner that's going to solve data science for you or your organization. Both languages are great in different situations, and both languages have amazing open source communities behind them.

A little bit about why the comparisons differ

As the header says, this will just be a little bit. For R, you can read up on the comparison documentation; the details section discusses string comparisons. For Python, you can check out the string comparison section in this post from The Python Guru.

In this post, we're going to ignore the details and the whys of the comparison. We're just going to sort all the letters & numbers. This shows us how things could pan out differently if we wrote the comparison using different cases or leetspeak replacements.

Sorting characters in R

> # create and sort a vector of letters & digits
> sorted_chars = sort(c(LETTERS, letters, 0:9))
> collapsed_sorted_chars = paste(sorted_chars, collapse='')
>
> print(collapsed_sorted_chars)
[1] "0123456789aAbBcCdDeEfFgGhHiIjJkKlLmMnNoOpPqQrRsStTuUvVwWxXyYzZ"

Sorting characters in Python

>>> import string
>>>
>>> # create and sort a list of letters & digits
>>> sorted_chars = sorted(string.ascii_letters + string.digits)
>>> collapsed_sorted_chars = ''.join(sorted_chars)
>>>
>>> print(collapsed_sorted_chars)
'0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz'

OOP Fractal Trees in R with R6, ggplot2, & gganimate (part 2)

Adam Spannbauer — Mon, 08 Oct 2018 20:01:40 +0000

This post is part 2 of 2, and, as stated in part 1, the end goal is to create an animated fractal tree with R6 & gganimate. Today, we will be animating the fractal_tree R6 class from part 1 with gganimate.

The below code and plot show where we're going to get by the end of this post.

# Create & animate R6 tree object
tree = fractal_tree_seq$new()
tree$animate()

Note: This post is meant to explore R6 functionality; it's not claiming to be the best way to create our fractal trees. Some design choices were solely to leverage varied features. Additionally, this post is more example-based than explanation based. For more in-depth explanations, I recommend going to this page from R6 or check out this chapter from Advanced R

Design

We already have a fractal_tree object that can create a single tree with branches positioned at a given angle. For simplicity, we will build our animated tree as a sequence of our (already defined) fractal_tree objects; each tree will be a frame in the animation. Disclaimer: if you end up running this code, you'll see that this approach might not be the most efficient approach, but it works.

Implementation

Note: This post's code assumes that the objects from part 1 are loaded into your R session. The complete code from part 1 can be found here

Sticking with the theme of the 2 part series, we'll create a single R6 class to house our animation process. The "Design" section above might seem to be written at a very high level, but it covers almost all of the implementation details that we'll discuss below.

`fractal_tree_seq`

The object doing the animation is given the name fractal_tree_seq since it is simply a sequence of fractal_trees. In the initialize method of the object, we loop the user provided angle_seq and create a tree at each angle in the sequence. Additionally, when we create each tree, we assign some metadata that shows which frame the tree belongs to. Lastly, in our initialize method we assign a color to each angle, this info will be used in plotting to give our animation some flare.

To wrap up our fractal_tree_seq class we add a public animate method that looks a lot like the plot method from part 1. The syntax of gganimate is very similar to ggplot2's, so experience with the later should make the animate code feel familiar. The only bit of gganimate code we add to the ggplot2 expression is + transition_manual(frame). This command will use the frame data we assigned in initialize to create a gif of our fractal_trees.

And that's it! We achieved the goal of creating and animating a fractal tree with R6 and gganimate.

fractal_tree_seq = R6Class('fractal_tree_seq',
                           public = list(
                             trees = data.frame(),
                             initialize = function(trunk_len = 10,
                                                   angle_seq = seq(0, 2 * pi - pi / 32, pi / 32),
                                                   len_decay = 0.7,
                                                   min_len = 0.25,
                                                   verbose = TRUE) {
                                 total = length(angle_seq)
                                 for (i in seq_along(angle_seq)) {
                                   if (verbose) cat(sprintf('creating tree %s of %s\n', i, total))
                                   angle = angle_seq[i]

                                   tree_i = fractal_tree$new(trunk_len = trunk_len,
                                                             delta_angle = angle,
                                                             len_decay = len_decay,
                                                             min_len = min_len)

                                   branches_i = tree_i$branches
                                   branches_i$angle = angle
                                   branches_i$frame = i

                                   self$trees = rbind(self$trees, branches_i)
                                 }

                                 angle_colors = data.frame(angle = sort(unique(self$trees$angle)))
                                 angle_colors$angle_color = rainbow(nrow(angle_colors))

                                 self$trees = merge(self$trees, angle_colors, all.x = TRUE, by = 'angle')
                               },  # initialize

                             animate = function() {
                                 ggplot(self$trees, aes(x, y, group = id)) +
                                   geom_line(aes(color = branch_color)) +
                                   geom_point(size = .2, aes(color = angle_color)) +
                                   scale_color_identity() +
                                   guides(color = FALSE, linetype = FALSE) +
                                   theme_void() +
                                   transition_manual(frame)
                               }
                             )  # public
                           )  #fractal_tree_seq

Final Product

This last section will be a few examples of using the functionality of our fractal_tree class.

# Create & animate R6 tree object
tree = fractal_tree_seq$new()
tree$animate()

# Create & animate R6 tree object with new min_len
tree = fractal_tree_seq$new(min_len = 3)
tree$animate()

# Create & animate R6 tree object with new angle_seq
tree_seq = fractal_tree_seq$new(angle_seq = runif(4, min=pi / 16, max=pi / 4))
tree$animate()

* made smaller since it's so distracting

OOP Fractal Trees in R with R6, ggplot2, & gganimate (part 1)

Adam Spannbauer — Sun, 07 Oct 2018 22:36:20 +0000

In this post, we're going to explore OOP in R as implemented by the R6 package. This post is part 1 of 2, and the end goal is to create an animated fractal tree with R6 & gganimate. Today, we will be creating a static plot of a fractal tree and a series of R6Class objects to help get us there.

The below code and plot show where we're going to get by the end of this post.

# Create & plot R6 tree object
tree = fractal_tree$new()
tree$plot()

Note: This post is meant to explore R6 functionality; it's not claiming to be the best way to create our fractal trees. Some design choices were solely to leverage varied features. Additionally, this post is more example-based than explanation based. For more in-depth explanations, I recomend going to this page from R6 or check out this chapter from Advanced R

Design

The sketch above shows the basic design of the fractal tree we'll be creating as an R6 object; let's unpack it. We'll have a vertical line as the trunk, and a series of branch lines that recursively sprout two at a time. Lastly, each child branch will have the same angle relative to its parent branch.

Let's translate the sketch into the object structure that we'll be using.

The way it's drawn up, we see that we'll be using two separate classes for the trunk and branches. The trunk and branches have a lot in common, so we'll be using the OOP concept of inheritance as implemented by R6. Below shows how we'll implement the trunk and branch classes using a base class and inheritance to stay DRY.

Implementation

We'll be starting in reverse order of how things were laid out in the design section. The code will be broken out into different sections for easier digestion. If you want to see all the code in one place you can view it here.

`branch_base`

The branch_base class will be the shared parent of our trunk & branch classes. So we want to pack it full of bits that they'll share. From an implementation standpoint, what they share is how they're going to be plotted by ggplot2. Each attribute that is initialized in public is an attribute that will be used to our plot method. Additionally, we use the active feature that will build a data.frame on the fly to represent our branches. Functions that are placed in active can be accessed as if they're static attributes.

branch_base = R6Class('branch_base',
                      public = list(
                        start_x = NA_integer_,
                        start_y = NA_integer_,
                        end_x = NA_integer_,
                        end_y = NA_integer_,
                        type = NA_character_,
                        id = NA_character_,
                        color = NA_character_
                        ),  # public

                      active = list(
                        df = function() {
                          x = c(self$start_x, self$end_x)
                          y = c(self$start_y, self$end_y)

                          data.frame(x = x, y = y, 
                                     type = self$type, 
                                     id = self$id,
                                     branch_color = self$color)
                          }
                        )  # active
                      )  # branch_base

`trunk`

The trunk class inherits from branch_base, so we don't have to think about initializing our attributes or redefining active. To define the class, we add an initialize method that will be used to actually create instances of trunk.

trunk = R6Class('trunk',
                inherit = branch_base,
                public = list(
                  initialize = function(len = 10, branch_color = '#000000') {
                    self$start_x = 0
                    self$start_y = 0
                    self$end_x = 0
                    self$end_y = len
                    self$type = 'trunk'
                    self$branch_color = branch_color

                    self$id = uuid::UUIDgenerate()
                    }
                  )  # public 
                )  # trunk

`branch`

The definition of branch is similar to trunk, but a little more involved. When we need to create a branch, the info that we'll be given is where it should start, what direction it should go in, and how long it should be. With these bits of information, we can use some trig to get the branch's endpoint. The rest of the initialize method is very similar to trunk.

branch = R6Class('branch',
                 inherit = branch_base,
                 public = list(
                   initialize = function(x, y, len = 5, theta = 45, 
                                         type = NA_character_, 
                                         branch_color='#000000') {
                     dy = sin(theta) * len
                     dx = cos(theta) * len

                     self$start_x = x
                     self$start_y = y
                     self$end_x = x + dx
                     self$end_y = y + dy

                     self$type = type
                     self$id = uuid::UUIDgenerate()
                     self$branch_color = branch_color
                     }
                   )  # public
                 )  # branch

`fractal_tree`

With trunk and branch defined we have the building blocks for our fractal_tree class. This class definition is going to be broken up into sections due to its length/complexity; the full definition can be seen here.

`public`

The public section of fractal_tree consists of the functionality we need to create and plot our tree.

The initialize method creates all the branches of our tree including the trunk. The private$grow_branches method is a recursive private method of our class that we'll define soon.

The remaining public method is plot, which, unsurprisingly, will plot our tree. The contents of this method should look fairly familiar to those who are familiar with ggplot2. Thanks to our set up we are able to plot our tree with relatively little effort.

public = list(
  delta_angle = NA_real_,
  len_decay = NA_real_,
  min_len = NA_real_,
  branch_left_color = NA_character_,
  branch_right_color = NA_character_,
  branches = data.frame(),

  initialize = function(trunk_len = 10,
                        delta_angle = pi / 8,
                        len_decay = 0.7,
                        min_len = 0.25,
                        trunk_color = '#000000',
                        branch_left_color = '#000000',
                        branch_right_color = '#adadad') {
    self$delta_angle = delta_angle
    self$len_decay = len_decay
    self$min_len = min_len
    self$branch_left_color = branch_left_color
    self$branch_right_color = branch_right_color

    self$branches = trunk$new(trunk_len, trunk_color)$df

    private$grow_branches(0, trunk_len,
                          len = trunk_len * len_decay,
                          angle_in = pi / 2)
  },

  plot = function() {
    ggplot(tree$branches, aes(x, y, group = id, color=branch_color)) +
      geom_line() +
      geom_point(color = 'darkgreen', size=0.5) +
      scale_color_identity() +
      guides(color = FALSE, linetype = FALSE) +
      theme_void()
  }
), # public

`private`

Our private section consists of a single method, grow_branches. This method will recursively build out our tree forever if given a starting point and an angle. To avoid infinite recursion we've built in the min_len attribute that will serve as a stopping point.

The body of the function consists of:

Creating 2 new branches that branch off to the left and right
Adding these branches to the branches attribute (the way this data.frame is dynamically grown could be re-written to be more efficient)
Repeating the process for the left branch (this recursively creates the entire left side of the tree)
Repeating the process for the right branch (this recursively creates the entire right side of the tree)

And that's it! We now finally have all the pieces in place to create and plot a fractal_tree with R6 and ggplot2.

private = list(
  grow_branches = function(start_x, start_y, 
                           len = 1,
                           angle_in = pi / 2,
                           parent_type = NA, 
                           parent_color = NA) {
    if (len >= self$min_len) {
      l_type = if (!is.na(parent_type)) parent_type else 'left'
      r_type = if (!is.na(parent_type)) parent_type else 'right'
      l_color = if (!is.na(parent_color)) parent_color else self$branch_left_color
      r_color = if (!is.na(parent_color)) parent_color else self$branch_right_color

      branch_left  = branch$new(start_x, start_y, len, angle_in + self$delta_angle, l_type, l_color)
      branch_right = branch$new(start_x, start_y, len, angle_in - self$delta_angle, r_type, r_color)

      self$branches = rbind(self$branches,
                            branch_left$df,
                            branch_right$df)

      private$grow_branches(branch_left$end_x, 
                            branch_left$end_y,
                            angle_in = angle_in + self$delta_angle,
                            len = len * self$len_decay,
                            parent_type = branch_left$type,
                            parent_color = branch_left$branch_color)

      private$grow_branches(branch_right$end_x, 
                            branch_right$end_y,
                            angle_in = angle_in - self$delta_angle,
                            len = len * self$len_decay,
                            parent_type =  branch_right$type,
                            parent_color = branch_right$branch_color)
    }
  }  # grow_branches
)  # private

Final Product

This last section will be a few examples of using the functionality of our fractal_tree class.

# Create & plot R6 tree object
tree = fractal_tree$new()
tree$plot()

# Create & plot R6 tree object with new angle
tree = fractal_tree$new(delta_angle = pi / 3)
tree$plot()

# Create & plot R6 tree object with new branch length decay
tree = fractal_tree$new(delta_angle = pi / 2,
                        len_decay = 0.6)
tree$plot()

# Create & plot R6 tree object with new color
tree = fractal_tree$new(trunk_color = 'tan4', 
                        branch_left_color = 'tan3',
                        branch_right_color = 'tan')
tree$plot()