galaaz 0.4.2 → 0.4.5

data/blogs/gknit/gknit.Rnd~

@@ -1,17 +0,0 @@
----
-title: "gKnit - Ruby Knitting with Galaaz"
-subtitle: "An example of tightly coupling Ruby and R in GraalVM"
-author: "Rodrigo Botafogo"
-tags: [Galaaz, Ruby, R, TruffleRuby, FastR, GraalVM, ggplot2]
-date: "16 October 2018"
-output:
-  html_document:
-  md_document:
-    variant: markdown_github
----
-
-```{r setup, echo=FALSE}
-
-```
-
-# Introduction

data/blogs/gknit/model.rb~

@@ -1,46 +0,0 @@
-require 'galaaz'
-
-# Loads the R 'caret' package.  If not present, installs it 
-R.install_and_loads 'caret'
-
-class Model
-  
-  attr_reader :data
-  attr_reader :test
-  attr_reader :train
-
-  #==========================================================
-  #
-  #==========================================================
-  
-  def initialize(data, percent_train:, seed: 123)
-
-    R.set__seed(seed)
-    @data = data
-    @percent_train = percent_train
-    @seed = seed
-    
-  end
-
-  #==========================================================
-  #
-  #==========================================================
-
-  def partition
-
-    train_index =
-      R.createDataPartition(@data.mpg, p: @percet_train,
-                            list: false, times: 1)
-    @train = @data[train_index, :all]
-    @test = @data[-train_index, :all]
-    
-  end
-  
-end
-
-mtcars = ~:mtcars
-model = Model.new(mtcars, percent_train: 0.8)
-model.partition
-puts model.train.head
-puts model.test.head
-

data/blogs/ruby_plot/ruby_plot.Rmd~

@@ -1,215 +0,0 @@
----
-title: "High Quality Scientific Plotting with Ruby in GraalVM"
-subtitle: "Also: Allowing R to use classes, modules, blocks, etc."
-author: "Rodrigo Botafogo"
-tags: [Galaaz, Ruby, R, TruffleRuby, FastR, GraalVM]
-date: "19 October 2018"
-output:
-  html_document:
-    self_contained: true
-    keep_md: true
-  pdf_document:
-    includes:
-      in_header: ["../../sty/galaaz.sty"]
-    number_sections: yes
----
-
-```{r setup, echo=FALSE}
-
-```
-
-# Introduction
-
-Ruby is a dynamic, interpreted, reflective, object-oriented, general-purpose
-programming language. It was designed and developed in the mid-1990s by Yukihiro
-"Matz" Matsumoto in Japan.  It reached high popularity with the development of Ruby on Rails
-(RoR) by David Heinemeier Hansson. RoR is a web application framework which was first release
-circa 2005 and makes extensive use of Ruby's metaprogramming features.  With the advend of
-RoR, Ruby became extremely popular and it peeked in popularity around 2008 according to the Tiobe
-index (https://www.tiobe.com/tiobe-index/ruby/).  From 2008 to 2015, it's popularity
-declined consistently and then started picking up again during the next 3 years.  At the time of
-this writing (November 2018), Ruby is ranked 16th in the Tiobe index.
-
-Python, considered a similar language to Ruby with similar features ranks 4th in the index.  The
-first three positions are takes by Java, C and C++.  One criticism often heard about Ruby, is
-that it is useful only for web applications while Python, with similar features has more diverse
-libraries, being useful for web applications with the Django framework, but also for
-scientific applications such as statistics, data analysis, big data, biology, etc.  This
-criticism is by no way wrong.  For scientific computing, Ruby lags way behind Python and R, the
-two most prestigous languages for this subject mater, with R being prefered by statisticians
-while Python is prefered by everyone else, because of it's gentle learning curve and more
-"natural" programming paradigm.
-
-Comes GraalVM into the picture:
-
-     GraalVM is a universal virtual machine for running applications written in JavaScript,
-     Python 3, Ruby, R, JVM-based languages like Java, Scala, Kotlin, and LLVM-based languages
-     such as C and C++.
-
-     GraalVM removes the isolation between programming languages and enables interoperability in a
-     shared runtime. It can run either standalone or in the context of OpenJDK, Node.js,
-     Oracle Database, or MySQL.
-
-     GraalVM allows you to write polyglot applications with a seamless way to pass values from one
-     language to another. With GraalVM there is no copying or marshaling necessary as it is with
-     other polyglot systems. This lets you achieve high performance when language boundaries are
-     crossed. Most of the time there is no additional cost for crossing a language boundary at all.
-
-     Often developers have to make uncomfortable compromises that require them to rewrite
-     their software in other languages. For example:
-
-      * “That library is not available in my language. I need to rewrite it.” 
-      * “That language would be the perfect fit for my problem, but we cannot run it in our environment.” 
-      * “That problem is already solved in my language, but the language is too slow.”
-    
-    With GraalVM we aim to allow developers to freely choose the right language for the task at
-    hand without making compromises.
-
-As stated above, GraalVM is a _universal_ virtual machine that allows Ruby and R (and other
-languages) to run on the same environment.  GraalVM allows polyglot applications to
-_seamlessly_ interact with one another and pass values from one language to the other.  Based
-on GraalVM, the Galaaz project was started.  Galaaz indends to integrate Ruby and R and allow
-those languages to _seamlessly_ interact in a way that the user will be unaware of such interaction.
-
-Library wrapping is an usual way of briging features from one library into another language.  For
-instance, whenever Python needs to perform operations efficiently, C libraries are wrap in Python.
-For the Python developer, the existence of such C library is of no importante.  The problem with
-library wrapping is that for any new library of interest, there is the need to hand craft a new
-wrapper.  With Galaaz, the same concept of wrapping was done, but instead of wrapping a C or an R
-library, Galaaz intends to wraps the whole of R language.  Doing so, all thousands of R libraries
-are immediately available to Ruby developers and any new library developed in R will also become
-available without requiring a new wrapping effort.
-
-In this article, the graphing ggplot2 library from R will be accessed by Ruby transparently,
-bringing to Ruby the power of high quality scientific plotting.  It might seem, from
-the exposed above, that Galaaz mainly benefits Ruby developers and might be of no
-consequence to the R developer.  This article will however show that migrating from R to
-Ruby with Galaaz is a matter of small syntactic changes.  Furthermore, R lacks some
-fundamental constructs for code reuse and large system construction. Using Galaaz, the R
-developer can easily migrate to a powerful OO language, at virtually no cost and then, as
-needs requires, she can add them to her toolbox.
-
-In this article we will explore the R ToothGrowth dataset.  In doing so, we will create some plots.
-Furthermore we will create a "Corporate Template" for our plots ensuring that any plot of the
-same type will have a consistent visualisation.
-
-# gKnit
-
-This document was written using rmarkdown and the corresponding HTML was generated by the gKnit
-application.  gKnit is a wrapper around the powerful 'knitr' application which converts
-rmarkdown text to many different output formats such as HTML, Latex, docx, etc.  The gKnit
-tool is still under active development and will soon be released.
-
-In rmarkdown, text and code can be part of the same document, and code blocks are marked
-with a special markup.  Interested readers can easily google 'knitr' and 'rmarkdown'.  in
-gKnit, each Ruby block is evaluated independently and 'eval' in Ruby creates a new scope, so,
-in order for a variable defined in a block to be accessible in another block, it has to be
-a global variable, preceded by the '$' sign.
-
-# Exploring the Dataset
-
-Let start by exploring our selected dataset.  In this dataset the response is the length of
-odontoblasts (cells responsible for tooth growth) in 60 guinea pigs. Each animal
-received one of three dose levels of vitamin C (0.5, 1, and 2 mg/day) by one of two
-delivery methods, orange juice or ascorbic acid (a form of vitamin C and coded as VC). 
-
-In Galaaz, in order to have access to an R variable pointed by an R symbol we use the
-corresponding Ruby symbol preceeded by the tilda ('~') function.
-
-```{ruby tooth_growth}
-# Read the R ToothGrowth variable and assign it to the
-# Ruby tooth_growth variable
-$tooth_growth = ~:ToothGrowth
-# convert the dose to a factor
-$tooth_growth.dose = $tooth_growth.dose.as__factor
-
-# print the first few elements of the dataset
-puts $tooth_growth.head
-```
-
-Great! We've managed to read the ToothGrowth dataset and take a look at its elements.  Observe
-that we have three columns in this dataset: 'len', 'supp' and 'dose'.  Accessing a column,
-for example the 'len' column, is done by doing '$tooth_growth.len'.  
-
-Let's explore some more details of this dataset.  In particular, let's look at its dimensions,
-structure and summary statistics.
-
-```{ruby stats}
-puts $tooth_growth.dim
-# chdck why NULL
-puts R.str(:ToothGrowth)
-puts $tooth_growth.summary
-```
-
-Let's now create our first plot with the given data by accessing ggplot2 from Ruby.  For Rubyist
-that have never seen or used ggplot2, here is the description found on ggplot home page:
-
-```
-"ggplot2 is a system for declaratively creating graphics, based on _The Grammar of Graphics_.
-You provide the data, tell ggplot2 how to map variables to aesthetics, what graphical 
-primitives to use, and it takes care of the details."
-```
-
-This description might be a bit cryptic and it is best to see it at work to understand it.
-Basically, in the _grammar of graphics_ each component of the plot such as the grid, the axis,
-the data, title, subtitle, etc. is added to the plot in layers to form the final graphics.
-
-In this plot bellow, the 'dose' is plotted on the 'x' axis and the tooth length on the 'y' axis.  Note
-the specification in the the 'aes' method: 'E.aes(x: :dose, y: :len)',  where ':dose' is the 'dose'
-column of the dataset and ':len' the 'len' column.  The 'aes' method is the _aesthetics_ for this
-plot.  Then, to this layer, the 'geom_boxplot' is added and the whole plot is printed.
-
-Note also that we have a call to 'R.png' before plotting and 'R.dev__off' after the print
-statement.  'R.png' opens a 'png' device for writing the plot.  When 'R.dev__off' is called, the
-device is closed and a 'png' file is created. If no name is given to the 'png' function, a file
-named 'Rplot<nnn>' is generated, where <nnn> is the number of the plot.  So, this first plot is
-called 'Rplot001.png'.  We can then include the generated 'png' file in
-this document, by adding an rmarkdown directive.
-
-```{ruby first_plot}
-require 'ggplot'
-
-R.png
-
-e = $tooth_growth.ggplot(E.aes(x: :dose, y: :len))
-print e + R.geom_boxplot
-
-R.dev__off
-```
-
-![ToothGrowth](Rplot001.png)
-
-We've just managed to generate our first plot in Ruby with only two lines of code.  This plot,
-however, if far from being pleasing to the eye.
-
-
-
-
-# Conclusion
-
-
-# Installing Galaaz
-
-## Prerequisites
-
-* GraalVM (>= rc8)
-* TruffleRuby
-* FastR
-
-The following R packages will be automatically installed when necessary, but could be installed prior
-to using gKnit if desired:
-
-* ggplot2
-* gridExtra
-* knitr
-
-Installation of R packages requires a development environment and can be time consuming.  In Linux,
-the gnu compiler and tools should be enough.  I am not sure what is needed on the Mac.
-
-## Preparation
-
-* gem install galaaz
-
-## Usage
-
-* gknit <filename>

data/examples/misc/moneyball.rb~

@@ -1,16 +0,0 @@
-# coding: utf-8
-
-require 'galaaz'
-
-# This dataset comes from Baseball-Reference.com.
-baseball = R.read__csv("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)
-wins_reg.summary.pp
-

data/examples/misc/subsetting.rb~

@@ -1,372 +0,0 @@
-# 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: R.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), df.n).pp
-print("\n")
-
-# [1] 1 1 1 2 2 2 2 2 3
-
-df[R.rep((1..df.nrow), 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: R.letters[(1..3)])
-# Not implemented yet
-# df.z = nil
-df.pp
-print("\n")
-
-df = R.data__frame(x: (1..3), y: (3..1), z: R.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.
-#------------------------------------------------------------------------------------------
-
-R.mtcars[R.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
-
-R.mtcars[(R.mtcars.gear == 5) & (R.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'
-p R.intersect(x2, y2)
-print("\n")
-
-# 10
-
-p 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