galaaz 0.4.0 → 0.4.1

data/examples/50Plots_MasterList/ScatterPlot.rb

@@ -0,0 +1,159 @@
+# -*- coding: utf-8 -*-
+
+##########################################################################################
+# @author Rodrigo Botafogo
+#
+# Copyright © 2018 Rodrigo Botafogo. All Rights Reserved. Permission to use, copy, modify, 
+# and distribute this software and its documentation, without fee and without a signed 
+# licensing agreement, is hereby granted, provided that the above copyright notice, this 
+# paragraph and the following two paragraphs appear in all copies, modifications, and 
+# distributions.
+#
+# IN NO EVENT SHALL RODRIGO BOTAFOGO BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT, SPECIAL, 
+# INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS, ARISING OUT OF THE USE OF 
+# THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF RODRIGO BOTAFOGO HAS BEEN ADVISED OF THE 
+# POSSIBILITY OF SUCH DAMAGE.
+#
+# RODRIGO BOTAFOGO SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED TO, 
+# THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
+# SOFTWARE AND ACCOMPANYING DOCUMENTATION, IF ANY, PROVIDED HEREUNDER IS PROVIDED "AS IS". 
+# RODRIGO BOTAFOGO HAS NO OBLIGATION TO PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, 
+# OR MODIFICATIONS.
+##########################################################################################
+
+require 'galaaz'
+require 'ggplot'
+
+module CorpTheme
+
+  #--------------------------------------------------------------------------------------
+  # Defines the plot theme (visualization).  In this theme we remove major and minor
+  # grids, borders and background.  We also turn-off scientific notation.
+  #--------------------------------------------------------------------------------------
+
+  def self.global_theme
+    
+    R.options(scipen: 999)  # turn-off scientific notation like 1e+48
+    
+    # remove major grids
+    global_theme = R.theme(panel__grid__major: E.element_blank())
+    # remove minor grids
+    global_theme = global_theme + R.theme(panel__grid__minor: E.element_blank)
+    # remove border
+    global_theme = global_theme + R.theme(panel__border: E.element_blank)
+    # remove background
+    global_theme = global_theme + R.theme(panel__background: E.element_blank)
+    # Change axis font
+    global_theme = global_theme +
+                   R.theme(axis__text: E.element_text(size: 8, color: "#000080"))
+    # change color of axis titles
+    global_theme = global_theme +
+                   R.theme(axis__title: E.element_text(
+                             color: "#000080", 
+                             face: "bold",
+                             size: 8,
+                             hjust: 1))
+  end
+  
+end
+
+
+class ScatterPlot
+
+  attr_accessor :title
+  attr_accessor :subtitle
+  attr_accessor :caption
+  attr_accessor :x_label
+  attr_accessor :y_label
+  
+  #--------------------------------------------------------------------------------------
+  # Initialize the plot with the data and the x and y variables
+  #--------------------------------------------------------------------------------------
+
+  def initialize(data, x:, y:)
+    @data = data
+    @x = x
+    @y = y
+  end
+
+  #--------------------------------------------------------------------------------------
+  # Define groupings by color and size
+  #--------------------------------------------------------------------------------------
+
+  def group_by(color: nil, size: nil)
+    @color_by = color
+    @size_by = size
+  end
+
+  #--------------------------------------------------------------------------------------
+  # Add a smoothing line, and if confidence is true the add a confidence interval, if
+  # false does not add the confidence interval
+  #--------------------------------------------------------------------------------------
+
+  def add_smoothing_line(method:, confidence: true)
+    @method = method
+    @confidence = confidence
+  end
+  
+  #--------------------------------------------------------------------------------------
+  # Creates the graph title, properly formated for this theme
+  # @param title [String] The title to add to the graph
+  # @return textGrob that can be included in a graph
+  #--------------------------------------------------------------------------------------
+
+  def graph_params(title: "", subtitle: "", caption: "", x_label: "", y_label: "")
+    R.labs(
+      title: title, 
+      subtitle: subtitle, 
+      caption: caption,
+      y_label: y_label, 
+      x_label: x_label, 
+    )
+  end
+
+  #--------------------------------------------------------------------------------------
+  # Prepare the plot's points
+  #--------------------------------------------------------------------------------------
+
+  def points
+    params = {}
+    params[:col] = @color_by if @color_by
+    params[:size] = @size_by if @size_by
+    R.geom_point(E.aes(params))
+  end
+
+  #--------------------------------------------------------------------------------------
+  # Plots the scatterplot
+  #--------------------------------------------------------------------------------------
+
+  def plot
+    R.awt
+    
+    puts @data.ggplot(E.aes(x: @x, y: @y)) +
+      points + 
+      R.geom_smooth(method: @method, se: @confidence) +
+      R.xlim(R.c(0, 0.1)) +
+      R.ylim(R.c(0, 500000)) + 
+      graph_params(title: @title,
+                   subtitle: @subtitle, 
+                   y_label: @y_label, 
+                   x_label: @x_label, 
+                   caption: @caption) +
+      CorpTheme.global_theme
+  end
+  
+end
+
+sp = ScatterPlot.new(~:midwest, x: :area, y: :poptotal)
+sp.title = "Midwest Dataset - Scatterplot"
+sp.subtitle = "Area Vs Population"
+sp.caption = "Source: midwest"
+sp.x_label = "Area"
+sp.y_label = "Population"
+sp.group_by(color: :state, size: :popdensity)    # try sp.group_by(color: :state)
+# available methods: "lm", "glm", "loess", "gam"
+sp.add_smoothing_line(method: "glm") 
+sp.plot
+
+
+a = gets.chomp

data/examples/R/calc.R

@@ -0,0 +1,21 @@
+x <- matrix(runif(1000000), 1000, 1000)
+mutual_R <- function(joint_dist) {
+ joint_dist <- joint_dist/sum(joint_dist)
+ mutual_information <- 0
+ num_rows <- nrow(joint_dist)
+ num_cols <- ncol(joint_dist)
+ colsums <- colSums(joint_dist)
+ rowsums <- rowSums(joint_dist)
+ for(i in seq_along(1:num_rows)){
+  for(j in seq_along(1:num_cols)){
+   temp <- log((joint_dist[i,j]/(colsums[j]*rowsums[i])))
+   if(!is.finite(temp)){
+    temp = 0
+   }
+   mutual_information <-
+    mutual_information + joint_dist[i,j] * temp
+  }
+ }
+ mutual_information
+}
+system.time(mutual_R(x))

data/examples/R/java_interop.R

@@ -0,0 +1,29 @@
+library(grid)
+openJavaWindow <- function () {
+   # create image and register graphics
+   imageClass <- java.type('java.awt.image.BufferedImage')
+   image <- new(imageClass, 450, 450, imageClass$TYPE_INT_RGB);
+   graphics <- image$getGraphics()
+   graphics$setBackground(java.type('java.awt.Color')$white);
+   grDevices:::awt(image$getWidth(), image$getHeight(), graphics)
+
+   # draw image
+   grid.newpage()
+   pushViewport(plotViewport(margins = c(5.1, 4.1, 4.1, 2.1)))
+   grid.xaxis(); grid.yaxis()
+   grid.points(x = runif(10, 0, 1), y = runif(10, 0, 1),
+        size = unit(0.01, "npc"))
+
+   # open frame with image
+   imageIcon <- new("javax.swing.ImageIcon", image)
+   label <- new("javax.swing.JLabel", imageIcon)
+   panel <- new("javax.swing.JPanel")
+   panel$add(label)
+   frame <- new("javax.swing.JFrame")
+   frame$setMinimumSize(new("java.awt.Dimension",
+                image$getWidth(), image$getHeight()))
+   frame$add(panel)
+   frame$setVisible(T)
+   while (frame$isVisible()) Sys.sleep(1)
+}
+openJavaWindow()

data/examples/misc/moneyball.rb

@@ -0,0 +1,33 @@
+# coding: utf-8
+
+require 'galaaz'
+
+local_dir = File.expand_path File.dirname(__FILE__)
+
+# This dataset comes from Baseball-Reference.com.
+baseball = R.read__csv("#{local_dir}/baseball.csv")
+
+# Lets look at the data available for Momeyball.
+moneyball = baseball.subset(baseball.Year < 2002)
+
+# Let's see if we can predict the number of wins, by looking at
+# runs allowed (RA) and runs scored (RS).  RD is the runs difference.
+# We are making a linear model for predicting wins (W) based on RD
+moneyball.RD = moneyball.RS - moneyball.RA
+wins_reg = R.lm(+:W =~ +:RD, data: moneyball)
+
+def show(title, data)
+  puts title
+  puts "=" * title.size
+  puts data
+  puts "=" * title.size
+  puts
+end
+
+puts "Fitting a linear model on the Baseball dataset as done in Moneyball:"
+puts
+show "Coefficients of the Linear Regression", wins_reg.coefficients
+show "Fitted values summary:", wins_reg.fitted__values.summary
+show "Residuals summary", wins_reg.residuals.summary
+
+

data/examples/misc/subsetting.rb

@@ -0,0 +1,374 @@
+# coding: utf-8
+
+require 'galaaz'
+
+# This examples were extracted from "Advanced R", by Hadley Wickham, available on the
+# web at: http://adv-r.had.co.nz/Subsetting.html#applications
+
+#------------------------------------------------------------------------------------------
+# Lookup tables (character subsetting)
+# Character matching provides a powerful way to make lookup tables.
+# Say you want to convert abbreviations:
+#------------------------------------------------------------------------------------------
+
+x = R.c("m", "f", "u", "f", "f", "m", "m")
+lookup = R.c(m: "Male", f: "Female", u: R::NA)
+lookup[x].pp
+print("\n")
+
+#       m        f        u        f        f        m        m 
+#  "Male" "Female"       NA "Female" "Female"   "Male"   "Male" 
+
+R.unname(lookup[x]).pp
+print("\n")
+
+# [1] "Male"   "Female" NA  "Female" "Female" "Male"   "Male"  
+
+
+#------------------------------------------------------------------------------------------
+# Matching and merging by hand (integer subsetting)
+#------------------------------------------------------------------------------------------
+
+# You may have a more complicated lookup table which has multiple columns of information.
+# Suppose we have a vector of grades, and a table that describes their properties:
+# In R a vector c(1, 2, 3) is a double vector, when using polyglot R.c(1, 2, 3) is an
+# integer vector, the equivalent of doing c(1L, 2L, 3L) in R.  Function 'match' does not
+# work correctly with integer vector, it has to be a double.  
+grades = R.c(1.0, 2.0, 2.0, 3.0, 1.0)
+
+info = R.data__frame(
+  grade: (3..1),
+  desc: R.c("Excellent", "Good", "Poor"),
+  fail: R.c(false, false, true)
+)
+
+# We want to duplicate the info table so that we have a row for each value in grades.
+# We can do this in two ways, either using match() and integer subsetting,
+# or rownames() and character subsetting:
+
+# Using match
+id = R.match(grades, info.grade)
+info[id, :all].pp
+print("\n")
+
+#    grade      desc  fail
+# 3       1      Poor  TRUE
+# 2       2      Good FALSE
+# 2.1     2      Good FALSE
+# 1       3 Excellent FALSE
+# 3.1     1      Poor  TRUE
+
+# Using rownames
+info.rownames = info.grade
+info[grades.as__character, :all].pp
+print("\n")
+
+#     grade      desc  fail
+# 1       3 Excellent FALSE
+# 2       2      Good FALSE
+# 2.1     2      Good FALSE
+# 3       1      Poor  TRUE
+# 1.1     3 Excellent FALSE
+
+#------------------------------------------------------------------------------------------
+# Random samples/bootstrap (integer subsetting)
+#------------------------------------------------------------------------------------------
+
+# You can use integer indices to perform random sampling or bootstrapping
+# of a vector or data frame. sample() generates a vector of indices, then
+# subsetting to access the values:
+df = R.data__frame(x: R.rep((1..3), each: 2), y: (6..1), z: (~:letters)[(1..6)])
+
+# Set seed for reproducibility
+R.set__seed(10)
+
+# Randomly reorder
+df[R.sample(df.nrow), :all].pp
+print("\n")
+
+#   x y z
+# 4 2 3 d
+# 2 1 5 b
+# 5 3 2 e
+# 3 2 4 c
+# 1 1 6 a
+# 6 3 1 f
+
+# Select 3 random rows
+df[R.sample(df.nrow, 3), :all].pp
+print("\n")
+
+#   x y z
+# 2 1 5 b
+# 6 3 1 f
+# 3 2 4 c
+
+# Select 6 bootstrap replicates
+df[R.sample(df.nrow, 6, rep: true), :all].pp
+print("\n")
+
+#     x y z
+# 3   2 4 c
+# 4   2 3 d
+# 4.1 2 3 d
+# 1   1 6 a
+# 4.2 2 3 d
+# 3.1 2 4 c
+
+#------------------------------------------------------------------------------------------
+# Ordering (integer subsetting)
+#------------------------------------------------------------------------------------------
+
+x = R.c("b", "c", "a")
+x.order.pp
+print("\n")
+
+# [1] 3 1 2
+
+x[x.order].pp
+print("\n")
+
+# [1] "a" "b" "c"
+
+# Randomly reorder df
+df2 = df[R.sample(df.nrow), (3..1)]
+df2.pp
+print("\n")
+
+#   z y x
+# 3 c 4 2
+# 1 a 6 1
+# 2 b 5 1
+# 4 d 3 2
+# 6 f 1 3
+# 5 e 2 3
+
+df2[df2.x.order, :all].pp
+print("\n")
+
+#   z y x
+# 1 a 6 1
+# 2 b 5 1
+# 3 c 4 2
+# 4 d 3 2
+# 6 f 1 3
+# 5 e 2 3
+
+df2[:all, df2.names.order].pp
+print("\n")
+
+#   x y z
+# 3 2 4 c
+# 1 1 6 a
+# 2 1 5 b
+# 4 2 3 d
+# 6 3 1 f
+# 5 3 2 e
+
+#------------------------------------------------------------------------------------------
+# Expanding aggregated counts (integer subsetting)
+# 
+# Sometimes you get a data frame where identical rows have been collapsed into one and a
+# count column has been added. rep() and integer subsetting make it easy to uncollapse
+# the data by subsetting with a repeated row index:
+#------------------------------------------------------------------------------------------
+
+df = R.data__frame(x: R.c(2, 4, 1), y: R.c(9, 11, 6), n: R.c(3, 5, 1))
+R.rep((1..(df.nrow << 0)), df.n).pp
+print("\n")
+
+# [1] 1 1 1 2 2 2 2 2 3
+
+df[R.rep((1..df.nrow << 0), df.n), :all].pp
+print("\n")
+
+#     x  y n
+# 1   2  9 3
+# 1.1 2  9 3
+# 1.2 2  9 3
+# 2   4 11 5
+# 2.1 4 11 5
+# 2.2 4 11 5
+# 2.3 4 11 5
+# 2.4 4 11 5
+# 3   1  6 1
+
+#------------------------------------------------------------------------------------------
+# Removing columns from data frames (character subsetting)
+#
+# There are two ways to remove columns from a data frame. You can set individual columns
+# to nil:
+#------------------------------------------------------------------------------------------
+
+df = R.data__frame(x: (1..3), y: (3..1), z: (~:letters)[(1..3)])
+# Not implemented yet
+# df.z = nil
+df.pp
+print("\n")
+
+df = R.data__frame(x: (1..3), y: (3..1), z: (~:letters)[(1..3)])
+df[R.c("x", "y")].pp
+print("\n")
+
+#   x y
+# 1 1 3
+# 2 2 2
+# 3 3 1
+
+df[df.names.setdiff("z")].pp
+print("\n")
+
+#   x y
+# 1 1 3
+# 2 2 2
+# 3 3 1
+
+#------------------------------------------------------------------------------------------
+# Selecting rows based on a condition (logical subsetting)
+#
+# Because it allows you to easily combine conditions from multiple columns, logical
+# subsetting is probably the most commonly used technique for extracting rows out of
+# a data frame.
+#------------------------------------------------------------------------------------------
+
+mtcars = ~:mtcars
+
+mtcars[mtcars.gear == 5, :all].pp
+print("\n")
+
+#                 mpg cyl  disp  hp drat    wt qsec vs am gear carb
+# Porsche 914-2  26.0   4 120.3  91 4.43 2.140 16.7  0  1    5    2
+# Lotus Europa   30.4   4  95.1 113 3.77 1.513 16.9  1  1    5    2
+# Ford Pantera L 15.8   8 351.0 264 4.22 3.170 14.5  0  1    5    4
+# Ferrari Dino   19.7   6 145.0 175 3.62 2.770 15.5  0  1    5    6
+# Maserati Bora  15.0   8 301.0 335 3.54 3.570 14.6  0  1    5    8
+
+mtcars[(mtcars.gear == 5) & (mtcars.cyl == 4), :all].pp
+print("\n")
+
+#                mpg cyl  disp  hp drat    wt qsec vs am gear carb
+# Porsche 914-2 26.0   4 120.3  91 4.43 2.140 16.7  0  1    5    2
+# Lotus Europa  30.4   4  95.1 113 3.77 1.513 16.9  1  1    5    2
+
+
+#------------------------------------------------------------------------------------------
+# Boolean algebra vs. sets (logical & integer subsetting)
+# 
+# It’s useful to be aware of the natural equivalence between set operations (integer
+# subsetting) and boolean algebra (logical subsetting)
+#------------------------------------------------------------------------------------------
+
+x = R.sample(10) < 4
+x.which.pp
+print("\n")
+
+# [1]  3  7 10
+
+#===
+x1 = R.c((1..10)) % 2 == 0
+x1.pp
+print("\n")
+
+# [1] FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE
+
+#===
+x2 = x1.which
+x2.pp
+print("\n")
+
+# [1]  2  4  6  8 10
+
+#===
+y1 = R.c((1..10)) % 5 == 0
+y1.pp
+print("\n")
+
+# [1] FALSE FALSE FALSE FALSE  TRUE FALSE FALSE FALSE FALSE  TRUE
+
+#===
+y2 = y1.which
+y2.pp
+print("\n")
+
+# [1]  5 10
+
+#===
+# X & Y <-> intersect(x, y)
+(x1 & y1).pp
+print("\n")
+
+# [1] FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE FALSE  TRUE
+
+#===
+# This example shows the problem with having R objects returning either
+# vector or scalar.  We don't know the type of the result of applying
+# intersect.  If this is a vector, then we need to print it with pp
+# but if this is a scalar, we need to print it with regular Ruby 'p' or
+# 'print'
+puts R.intersect(x2, y2)
+print("\n")
+
+# 10
+
+puts x2.intersect y2
+
+# 10
+
+#===
+# X | Y <-> union(x, y)
+(x1 | y1).pp
+print("\n")
+
+# [1] FALSE  TRUE FALSE  TRUE  TRUE  TRUE FALSE  TRUE FALSE  TRUE
+
+#===
+R.union(x2, y2).pp
+print("\n")
+
+# [1]  2  4  6  8 10  5
+
+(x2.union y2).pp
+
+# [1]  2  4  6  8 10  5
+
+#===
+# X & !Y <-> setdiff(x, y)
+(x1 & !y1).pp
+print("\n")
+
+# [1] FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE  TRUE FALSE FALSE
+
+#===
+R.setdiff(x2, y2).pp
+print("\n")
+
+# [1] 2 4 6 8
+
+(x2.setdiff y2).pp
+
+# [1] 2 4 6 8
+
+
+#===
+# xor(X, Y) <-> setdiff(union(x, y), intersect(x, y))
+R.xor(x1, y1).pp
+print("\n")
+
+#  [1] FALSE  TRUE FALSE  TRUE  TRUE  TRUE FALSE  TRUE FALSE FALSE
+
+# Writing the same as the last example in a Ruby style
+(x1.xor y1).pp
+
+#  [1] FALSE  TRUE FALSE  TRUE  TRUE  TRUE FALSE  TRUE FALSE FALSE
+
+#===
+R.setdiff(R.union(x2, y2), R.intersect(x2, y2)).pp
+print("\n")
+
+# [1] 2 4 6 8 5
+
+# Writing the same as the last example in a Ruby style
+((x2.union y2).setdiff (x2.intersect y2)).pp
+print("\n")
+
+# [1] 2 4 6 8 5