galaaz 0.5.0 → 2.0.0

data/blogs/test/test.Rmd

@@ -0,0 +1,14 @@
+---
+title: "Minimal gknit callback test"
+output: html_document
+---
+
+```{r setup, echo=FALSE}
+# Empty setup so structure matches oh_my; first engine run is the ruby chunk below.
+```
+
+```{ruby fig.ext='png'}
+# Minimal ruby chunk: triggers process_options and options['fig.ext'].unboxed_get(0).
+# Same R code path as oh_my.Rmd first ruby chunk (sends .GlobalEnv$g2_vN <- g2_vM[[1]] for fig.ext).
+puts "ok"
+```

data/examples/bioconductor_deseq2_airway/Documentation/DESeq2-airway-walkthrough.md

@@ -0,0 +1,56 @@
+# DESeq2 Airway Walkthrough (Bioconductor + galaaz)
+
+This document defines the first Bioconductor example we will implement with `galaaz`.
+
+## Goal
+
+Run a canonical differential expression analysis from Bioconductor using `DESeq2` and the `airway` dataset, then validate that the workflow executes correctly with `galaaz`.
+
+## Scope
+
+- Focus on workflow execution and interoperability.
+- Install Bioconductor dependencies directly in R (outside `galaaz`).
+- Keep biological interpretation minimal for this first example.
+
+## Precondition
+
+Before running this example in `galaaz`, install and verify in R:
+
+- `BiocManager`
+- `DESeq2`
+- `airway`
+
+## Primer (what we are doing)
+
+- RNA-seq count data contains integer read counts per gene and per sample.
+- We compare treated vs untreated samples to find genes with significant changes.
+- `DESeq2` models count data and returns:
+  - `log2FoldChange` (effect size)
+  - `pvalue`
+  - `padj` (multiple-testing corrected p-value)
+
+## Planned Workflow
+
+1. Load `DESeq2` and `airway`.
+2. Load airway data and inspect counts plus sample metadata.
+3. Define a design formula for condition effect (with relevant covariate if used in canonical example).
+4. Build a `DESeqDataSet` object.
+5. Pre-filter low-count genes.
+6. Run `DESeq()` to fit the model.
+7. Extract `results()` for the treatment comparison.
+8. Sort and inspect top hits by adjusted p-value.
+9. Produce one standard QC/result plot (for example `plotMA`).
+
+## Validation Checks
+
+- Packages load without runtime errors in the target environment.
+- `DESeqDataSet` object is created successfully.
+- `DESeq()` completes.
+- `results()` returns expected columns and non-empty output.
+- At least one standard DESeq2 plot call runs successfully.
+
+## Out of Scope (for now)
+
+- Installing packages via `galaaz`.
+- Performance tuning or optimization.
+- Deep biological interpretation of gene-level findings.

data/examples/bioconductor_deseq2_airway/bench_galaaz_three_same_process.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+# Run a galaaz DESeq2 airway example three times in one JRuby process (warm-up semantics).
+#
+# Usage (from repository root):
+#   bin/galaaz-jruby examples/bioconductor_deseq2_airway/bench_galaaz_three_same_process.rb
+#   bin/galaaz-jruby examples/bioconductor_deseq2_airway/bench_galaaz_three_same_process.rb optimized
+#   bin/galaaz-jruby examples/bioconductor_deseq2_airway/bench_galaaz_three_same_process.rb original
+
+require 'galaaz'
+
+root = File.expand_path('../..', __dir__)
+Dir.chdir(root)
+
+variant = (ARGV[0] || 'optimized').downcase
+script = case variant
+         when 'original'
+           'deseq2_airway_galaaz.rb'
+         when 'optimized'
+           'deseq2_airway_galaaz_optimized.rb'
+         else
+           warn "Unknown variant #{variant.inspect}; use 'optimized' or 'original'"
+           exit 1
+         end
+
+path = File.expand_path(script, __dir__)
+
+unless File.file?(path)
+  warn "Missing #{path}"
+  exit 1
+end
+
+puts "=== galaaz (#{variant}): three runs, same process (root: #{root})"
+times = []
+3.times do |i|
+  t0 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  load path
+  t1 = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  sec = t1 - t0
+  times << sec
+  puts format('galaaz run %d/3: %.2f s', i + 1, sec)
+end
+
+warm = times[1..2]
+ws = warm.sort
+warm_median = (ws[0] + ws[1]) / 2.0
+all_sorted = times.sort
+all_median = all_sorted[1]
+
+puts '---'
+puts format('Warm median (runs 2–3): %.2f s', warm_median)
+puts format('Warm mean (runs 2–3):   %.2f s', warm.sum / warm.size)
+puts format('All-run median:           %.2f s', all_median)

data/examples/bioconductor_deseq2_airway/bench_r_three_same_process.R

@@ -0,0 +1,34 @@
+# Run the DESeq2 airway pipeline three times in a single R process (fair vs galaaz warm-up).
+#
+# Usage (from repository root):
+#   Rscript examples/bioconductor_deseq2_airway/bench_r_three_same_process.R
+#   Rscript examples/bioconductor_deseq2_airway/bench_r_three_same_process.R /path/to/galaaz
+
+args <- commandArgs(trailingOnly = TRUE)
+root <- if (length(args) >= 1L) {
+  normalizePath(args[[1L]], winslash = "/", mustWork = TRUE)
+} else {
+  normalizePath(getwd(), winslash = "/", mustWork = TRUE)
+}
+
+Sys.setenv(GALAAZ_BENCH_ROOT = root)
+pipeline <- file.path(root, "examples/bioconductor_deseq2_airway/deseq2_airway_pipeline_for_bench.R")
+if (!file.exists(pipeline)) {
+  stop("Pipeline not found: ", pipeline, " (wrong GALAAZ_BENCH_ROOT?)")
+}
+
+cat("=== R: three runs, same process (repository root:", root, ")\n", sep = "")
+times <- numeric(3L)
+for (i in seq_len(3L)) {
+  st <- system.time({
+    sys.source(pipeline, envir = new.env(parent = globalenv()), keep.source = FALSE)
+  }, gcFirst = FALSE)
+  times[[i]] <- unname(st[["elapsed"]])
+  cat(sprintf("R run %d/3: %.2f s\n", i, times[[i]]))
+}
+
+warm <- times[2:3]
+cat("---\n")
+cat(sprintf("Warm median (runs 2–3): %.2f s\n", stats::median(warm)))
+cat(sprintf("Warm mean (runs 2–3):   %.2f s\n", mean(warm)))
+cat(sprintf("All-run median:           %.2f s\n", stats::median(times)))

data/examples/bioconductor_deseq2_airway/deseq2_airway_galaaz.rb

@@ -0,0 +1,33 @@
+require 'galaaz'
+
+R.library('DESeq2')
+R.library('airway')
+R.data('airway')
+
+airway = ~:airway
+
+# Build DESeq2 dataset with one-sided formula: ~ cell + dex.
+dds = R.DESeqDataSet(airway, design: (:all.til :cell + :dex))
+
+# Prefilter genes with almost no counts.
+keep = R.rowSums(R.counts(dds)) >= 10
+dds = dds[keep, :all]
+
+# Fit DE model and extract treatment effect.
+dds = R.DESeq(dds)
+res = R.results(dds, contrast: R.c('dex', 'trt', 'untrt'))
+
+# Compact sanity outputs for quick verification.
+puts "Samples: #{R.ncol(dds)}"
+puts "Genes after prefilter: #{R.nrow(dds)}"
+puts "Result rows: #{R.nrow(res)}"
+puts "Result columns: #{R.colnames(res)}"
+puts "Significant genes (padj < 0.05): #{R.sum(res.padj < 0.05, na__rm: true)}"
+
+res_ordered = res[R.order(res.padj), :all]
+puts R.head(R.as__data__frame(res_ordered), 10)
+
+# Standard DESeq2 plot call written to file.
+R.pdf('examples/bioconductor_deseq2_airway/plotMA_galaaz.pdf')
+R.plotMA(res, ylim: R.c(-5, 5))
+R.dev__off

data/examples/bioconductor_deseq2_airway/deseq2_airway_galaaz_optimized.rb

@@ -0,0 +1,34 @@
+require 'galaaz'
+
+R.library('DESeq2')
+R.library('airway')
+R.data('airway')
+
+airway = ~:airway
+
+# Build DESeq2 dataset with one-sided formula: ~ cell + dex.
+dds = R.DESeqDataSet(airway, design: (:all.til :cell + :dex))
+
+# Prefilter genes with almost no counts.
+keep = R.rowSums(R.counts(dds)) >= 10
+dds = dds[keep, :all]
+
+# Fit DE model and extract treatment effect.
+dds = R.DESeq(dds)
+res = R.results(dds, contrast: R.c('dex', 'trt', 'untrt'))
+
+# Ruby-style optimization: delegate object rendering to R print/cat.
+padj = res.padj
+res_ordered = res[R.order(padj), :all]
+
+R.cat('Samples:', R.ncol(dds), '\n')
+R.cat('Genes after prefilter:', R.nrow(dds), '\n')
+R.cat('Result rows:', R.nrow(res), '\n')
+R.cat('Result columns:', R.paste(R.colnames(res), collapse: ', '), '\n')
+R.cat('Significant genes (padj < 0.05):', R.sum(padj < 0.05, na__rm: true), '\n')
+R.print(R.head(res_ordered, 10))
+
+# Standard DESeq2 plot call written to file.
+R.pdf('examples/bioconductor_deseq2_airway/plotMA_galaaz_optimized.pdf')
+R.plotMA(res, ylim: R.c(-5, 5))
+R.dev__off

data/examples/bioconductor_deseq2_airway/deseq2_airway_minimal.R

@@ -0,0 +1,30 @@
+library(DESeq2)
+library(airway)
+
+# Load canonical airway example data.
+data(airway)
+airway$dex <- relevel(airway$dex, ref = "untrt")
+
+# Build DESeq2 dataset using cell line as covariate and dex as treatment.
+dds <- DESeqDataSet(airway, design = ~ cell + dex)
+
+# Prefilter genes with almost no counts.
+keep <- rowSums(counts(dds)) >= 10
+dds <- dds[keep, ]
+
+# Fit DE model and extract treatment effect.
+dds <- DESeq(dds)
+res <- results(dds, contrast = c("dex", "trt", "untrt"))
+
+# Compact sanity outputs for quick verification.
+cat("Samples:", ncol(dds), "\n")
+cat("Genes after prefilter:", nrow(dds), "\n")
+cat("Result rows:", nrow(res), "\n")
+cat("Result columns:", paste(colnames(res), collapse = ", "), "\n")
+cat("Significant genes (padj < 0.05):", sum(res$padj < 0.05, na.rm = TRUE), "\n")
+
+res_ordered <- res[order(res$padj), ]
+print(head(as.data.frame(res_ordered), 10))
+
+# Standard DESeq2 plot call used in the walkthrough.
+plotMA(res, ylim = c(-5, 5))

data/examples/bioconductor_deseq2_airway/deseq2_airway_pipeline_for_bench.R

@@ -0,0 +1,36 @@
+# DESeq2 airway pipeline for timing benchmarks.
+# Logic matches deseq2_airway_minimal.R; plot goes to PDF like the galaaz examples
+# (avoids default graphics device variance in headless/automated runs).
+#
+# Not loaded by default from other examples — use only via bench_r_three_same_process.R.
+
+library(DESeq2)
+library(airway)
+
+data(airway)
+airway$dex <- relevel(airway$dex, ref = "untrt")
+
+dds <- DESeqDataSet(airway, design = ~ cell + dex)
+
+keep <- rowSums(counts(dds)) >= 10
+dds <- dds[keep, ]
+
+dds <- DESeq(dds)
+res <- results(dds, contrast = c("dex", "trt", "untrt"))
+
+cat("Samples:", ncol(dds), "\n")
+cat("Genes after prefilter:", nrow(dds), "\n")
+cat("Result rows:", nrow(res), "\n")
+cat("Result columns:", paste(colnames(res), collapse = ", "), "\n")
+cat("Significant genes (padj < 0.05):", sum(res$padj < 0.05, na.rm = TRUE), "\n")
+
+res_ordered <- res[order(res$padj), ]
+print(head(as.data.frame(res_ordered), 10))
+
+root <- Sys.getenv("GALAAZ_BENCH_ROOT", unset = "")
+if (!nzchar(root)) {
+  stop("Set GALAAZ_BENCH_ROOT to the galaaz repository root before sourcing this file (see bench_r_three_same_process.R).")
+}
+pdf(file.path(root, "examples/bioconductor_deseq2_airway/plotMA_bench_R.pdf"))
+plotMA(res, ylim = c(-5, 5))
+invisible(dev.off())

data/examples/islr/all.rb

@@ -27,6 +27,19 @@ require 'ggplot'
 # load ISLR and MASS Libraries
 R.install_and_loads('ISLR', 'MASS')
 
+def galaaz_islr_all_debug(msg)
+  STDERR.puts "[DEBUG islr][all] #{Time.now.strftime('%H:%M:%S')} #{msg}"
+  STDERR.flush
+end
+
+galaaz_islr_all_debug('before require ch2.spec')
 require_relative 'ch2.spec'
+galaaz_islr_all_debug('after require ch2.spec')
+
+galaaz_islr_all_debug('before require ch3.spec')
 require_relative 'ch3.spec'
+galaaz_islr_all_debug('after require ch3.spec')
+
+galaaz_islr_all_debug('before require ch6.spec')
 require_relative 'ch6.spec'
+galaaz_islr_all_debug('after require ch6.spec')

data/examples/islr/ch2.spec.rb

@@ -69,8 +69,11 @@ context "ISLR" do
       R.set__seed(3)
       x = R.rnorm(50)
       y = x + R.rnorm(50, mean: 40, sd: 0.1)
-      expect(R.cor(x, y).all__equal(0.995717314227608)).to eq true
-      expect(x.cor(y).all__equal(0.995717314227608)).to eq true
+      cor_xy = R.cor(x, y)
+      expected = 0.995717314227608
+      expect(cor_xy.respond_to?(:all__equal) ? cor_xy.all__equal(expected) : (cor_xy - expected).abs < 1e-9).to eq true
+      cor_xy2 = x.cor(y)
+      expect(cor_xy2.respond_to?(:all__equal) ? cor_xy2.all__equal(expected) : (cor_xy2 - expected).abs < 1e-9).to eq true
     end
 
     it "should allow to setting the seed" do
@@ -84,16 +87,24 @@ context "ISLR" do
     it "should calculate the mean" do
       R.set__seed(3)
       y = R.rnorm(100)
-      expect(y.mean.all__equal(0.0110355710)).to eq true
+      m = y.mean
+      expect(m.respond_to?(:all__equal) ? m.all__equal(0.0110355710) : (m - 0.0110355710).abs < 1e-9).to eq true
     end
 
     it "should calculate the variance" do
       R.set__seed(3)
       y = R.rnorm(100)
-      
-      expect(y.var.all__equal(0.732867501277449)).to eq true
-      expect(y.var.sqrt.all__equal(0.856076808047881)).to eq true
-      expect(y.sd.all__equal(0.856076808047881)).to eq true
+      v = y.var
+      sd = y.sd
+      expected_var = 0.732867501277449
+      expected_sd = 0.856076808047881
+      expect(v.respond_to?(:all__equal) ? v.all__equal(expected_var) : (v - expected_var).abs < 1e-9).to eq true
+      expect(sd.respond_to?(:all__equal) ? sd.all__equal(expected_sd) : (sd - expected_sd).abs < 1e-9).to eq true
+      # var.sqrt should match sd when both are available
+      if v.respond_to?(:sqrt)
+        s = v.sqrt
+        expect(s.respond_to?(:all__equal) ? s.all__equal(expected_sd) : (s - expected_sd).abs < 1e-9).to eq true
+      end
     end
 
   end
@@ -101,8 +112,15 @@ context "ISLR" do
   context "Chapter 2 - Graphics" do
 
     it "should plot graphics" do
+      def galaaz_islr_debug(msg)
+        STDERR.puts "[DEBUG islr][ch2.spec][#{Time.now.strftime('%H:%M:%S')}] #{msg}"
+        STDERR.flush
+      end
+
       # To see the graphic we need to set the device to awt
+      galaaz_islr_debug 'before R.awt'
       R.awt
+      galaaz_islr_debug 'after R.awt'
       x = R.rnorm(100)
       y = R.rnorm(100)
       # plot commands do not work.  Need to work with ggplot or grid
@@ -113,16 +131,28 @@ context "ISLR" do
               ylab: "this is the y-axis",
               main: "Plot of X vs Y")
         .print
+      galaaz_islr_debug 'after qplot.print'
       # the graphics dies when the script ends... waiting 3 secs
       # so that the graphic can be seen
+      galaaz_islr_debug 'before sleep(3)'
       sleep(3)
+      galaaz_islr_debug 'after sleep(3)'
+      R.dev__off
     end
 
     it "should create a jpeg file" do
+      def galaaz_islr_debug(msg)
+        STDERR.puts "[DEBUG islr][ch2.spec][#{Time.now.strftime('%H:%M:%S')}] #{msg}"
+        STDERR.flush
+      end
+
+      galaaz_islr_debug 'jpeg test: start'
       R.jpeg("/home/rbotafogo/desenv/galaaz/examples/islr/x_y_rnorm.jpg")
       R.df = R.data__frame(x: R.rnorm(100), y: R.rnorm(100))
+      galaaz_islr_debug 'jpeg test: about to qplot'
       puts R.qplot(:x, :y, data: :df, col: "green")
       R.dev__off
+      galaaz_islr_debug 'jpeg test: after R.dev__off'
     end
 
     it "creates sequences with 'seq'" do

data/examples/islr/ch3.spec.rb

@@ -24,5 +24,14 @@
 require 'galaaz'
 require 'ggplot'
 
-require_relative 'ch3_boston'
-require_relative 'ch3_multiple_regression'
+context "ISLR" do
+  context "Chapter 3 - Lab" do
+    it "runs ch3_boston (graphics + regression)" do
+      load File.expand_path('ch3_boston.rb', __dir__)
+    end
+
+    it "runs ch3_multiple_regression (non-linear transformations)" do
+      load File.expand_path('ch3_multiple_regression.rb', __dir__)
+    end
+  end
+end

data/examples/islr/ch3_boston.rb

@@ -25,12 +25,23 @@ require 'ggplot'
 
 R.install_and_loads('ISLR', 'MASS')
 
+# Minimal breadcrumb logging to understand where the script gets stuck
+# when running `rake islr:all` (chapters are executed as scripts).
+def galaaz_islr_debug(msg)
+  STDERR.puts "[DEBUG islr][ch3_boston] #{Time.now.strftime('%H:%M:%S')} #{msg}"
+  STDERR.flush
+end
+
 # Simple linear regression from ISLR book.  Chapter 3 Lab
 # We are using qplot for plotting.  It would be better to use
 # ggplot2, but this is just to show simple ploting.
 
 # load boston data frame on variable boston
+bala = nil
+bala2 = nil
+galaaz_islr_debug('start; loading Boston')
 boston = ~:Boston
+galaaz_islr_debug('Boston loaded; printing names/lm')
 
 puts boston.names
 
@@ -49,7 +60,9 @@ puts pred
 puts boston.lstat
 puts boston.medv
 
+galaaz_islr_debug('before R.awt')
 R.awt
+galaaz_islr_debug('after R.awt; before first plot')
 
 puts R.qplot(:lstat, :medv, data: :Boston, col: "red") +
      R.geom_abline(intercept: boston_lm.coef[1],
@@ -62,25 +75,39 @@ puts R.qplot(:lstat, :medv, data: :Boston, col: "red") +
 # a = gets.chomp
 
 # sleep two seconds so that the graph shows up
+galaaz_islr_debug('sleep(2) after first plot')
 sleep(2)
+galaaz_islr_debug('grid__newpage #1')
 R.grid__newpage
 
+galaaz_islr_debug('building my_data #2 and plotting #2')
 R.my_data = R.data__frame(pred: R.predict(boston_lm), res: R.residuals(boston_lm))
 puts R.qplot(:pred, :res, data: :my_data)
 
+galaaz_islr_debug('sleep(2) after plot #2')
 sleep(2)
+galaaz_islr_debug('grid__newpage #2')
 R.grid__newpage
 
+galaaz_islr_debug('building my_data #3 and plotting #3')
 R.my_data = R.data__frame(pred: R.predict(boston_lm), res: R.rstudent(boston_lm))
 puts R.qplot(:pred, :res, data: :my_data)
 
+galaaz_islr_debug('sleep(2) after plot #3')
 sleep(2)
+galaaz_islr_debug('grid__newpage #3')
 R.grid__newpage
 
+galaaz_islr_debug('hatvalues + plotting #4')
 vals = R.hatvalues(boston_lm)
 R.my_data = R.data__frame(size: (1..vals.size), values: vals)
 # method size returns a Numeric... size is equivalent to 'length << 0'
 puts R.qplot(:size, :values, data: :my_data)
 
+galaaz_islr_debug('sleep(2) after plot #4')
 sleep(2)
+galaaz_islr_debug('grid__newpage #4')
 R.grid__newpage
+
+# Close the graphics device so later chapters don't keep an open AWT window.
+R.dev__off

data/examples/islr/ch6.spec.rb

@@ -29,34 +29,57 @@ context "ISLR" do
 
   context "Chapter 6 - Subset Selection Methods - page 244" do
 
+    def galaaz_islr_debug(msg)
+      STDERR.puts "[DEBUG islr][ch6.spec][#{Time.now.strftime('%H:%M:%S')}] #{msg}"
+      STDERR.flush
+    end
+
     before(:each) do
       @hitters = ~:Hitters
     end
     
     it "Should access the names of the dataset" do
+      galaaz_islr_debug 'test1 start (names/dim)'
       expect(@hitters.names[1] == "AtBat").to eq true
       expect(@hitters.names[5] == "RBI").to eq true
       expect(@hitters.names[11] == "CRuns").to eq true
       expect(@hitters.dim == R.c(322, 20)).to eq true
+      galaaz_islr_debug 'test1 end'
     end
 
     it "Should count na's using 'R.sum'" do
+      galaaz_islr_debug 'test2 start (R.sum)'
       expect(R.sum(@hitters.Salary.is__na) == 59).to eq true
       expect(R.sum(@hitters.Salary.is__na)).to eq 59
+      galaaz_islr_debug 'test2 end'
     end
 
     it "Should count na's using Ruby Enumerable 'sum'" do
+      galaaz_islr_debug "test3 start (Ruby Enumerable sum over Salary)"
+      yielded = 0
+      salary = @hitters.Salary
+      galaaz_islr_debug "test3 salary fetched; about to salary.size"
+      sz = salary.size
+      galaaz_islr_debug "test3 salary.size=#{sz}; about to Salary.sum"
       # method 'sum' is a Ruby Enumerable method.  To count na's we can loop through
       # every element and check if they are na or not.  Note that the return os
       # is__na is an R::Vector, so we need to 'pop' the value to a Ruby value in
       # ordet to apply the '?' method
-      expect(@hitters.Salary.sum { |e| (e.is__na == true)? 1 : 0 }).to eq 59
+      got = @hitters.Salary.sum do |e|
+        yielded += 1
+        galaaz_islr_debug("test3 yield #{yielded}") if yielded % 100 == 0
+        (e.is__na == true) ? 1 : 0
+      end
+      galaaz_islr_debug "test3 end (yielded=#{yielded}, got=#{got})"
+      expect(got).to eq 59
     end
 
     it "should remove missing values with na__omit" do
+      galaaz_islr_debug 'test4 start (na__omit)'
       @hitters = @hitters.na__omit
       expect(@hitters.dim == R.c(263, 20)).to eq true
       expect(R.sum(@hitters.is__na)).to eq 0
+      galaaz_islr_debug 'test4 end'
     end
     
   end