Update app.R

app.R

@@ -1,58 +1,435 @@
+# ============================================================
+#  app.R  |  Shiny App for Rerandomization with fastrerandomize
+# ============================================================
+# 1) The user can upload or simulate a covariate dataset (X).
+# 2) They specify rerandomization parameters: n_treated, acceptance prob, etc.
+# 3) The app generates a set of accepted randomizations under rerandomization.
+# 4) The user can optionally upload or simulate outcomes (Y) and run a randomization test.
+# 5) The app displays distribution of the balance measure (e.g., Hotelling's T^2) and final p-value/fiducial interval.
+
+# ----------------------------
+# Load required packages
+# ----------------------------
 library(shiny)
-library(bslib)
-library(dplyr)
-library(ggplot2)
+library(shinydashboard)
+library(DT)               # For data tables
+library(ggplot2)          # For basic plotting
+library(fastrerandomize)  # Our rerandomization package
 
-df <- readr::read_csv("penguins.csv")
-# Find subset of columns that are suitable for scatter plot
-df_num <- df |> select(where(is.numeric), -Year)
+# For production apps, ensure fastrerandomize is installed:
+# install.packages("devtools")
+# devtools::install_github("cjerzak/fastrerandomize-software/fastrerandomize")
 
-ui <- page_sidebar(
-  theme = bs_theme(bootswatch = "minty"),
-  title = "Penguins explorer",
-  sidebar = sidebar(
-    varSelectInput("xvar", "X variable", df_num, selected = "Bill Length (mm)"),
-    varSelectInput("yvar", "Y variable", df_num, selected = "Bill Depth (mm)"),
-    checkboxGroupInput("species", "Filter by species",
-      choices = unique(df$Species), selected = unique(df$Species)
-    ),
-    hr(), # Add a horizontal rule
-    checkboxInput("by_species", "Show species", TRUE),
-    checkboxInput("show_margins", "Show marginal plots", TRUE),
-    checkboxInput("smooth", "Add smoother"),
+# ---------------------------------------------------------
+# UI Section
+# ---------------------------------------------------------
+ui <- dashboardPage(
+  
+  # ========== Header =================
+  dashboardHeader(
+    title = tags$span(
+      "fastrerandomize Demo", 
+      style = "font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;"
+    )
   ),
-  plotOutput("scatter")
-)
+  
+  # ========== Sidebar ================
+  dashboardSidebar(
+    sidebarMenu(
+      menuItem("Data & Covariates", tabName = "datatab", icon = icon("database")),
+      menuItem("Generate Randomizations", tabName = "gennet", icon = icon("random")),
+      menuItem("Randomization Test", tabName = "randtest", icon = icon("flask"))
+    )
+  ),
+  
+  # ========== Body ===================
+  dashboardBody(
+    
+    # A little CSS to keep the design timeless and clean
+    tags$head(
+      tags$style(HTML("
+        .smalltext { font-size: 90%; color: #555; }
+        .shiny-output-error { color: red; }
+        .shiny-input-container { margin-bottom: 15px; }
+      "))
+    ),
+    
+    tabItems(
+      
+      # ------------------------------------------------
+      # 1) Data & Covariates Tab
+      # ------------------------------------------------
+      tabItem(
+        tabName = "datatab",
+        
+        fluidRow(
+          box(width = 5, title = "Covariate Data: Upload or Simulate",
+              status = "primary", solidHeader = TRUE,
+              
+              radioButtons("data_source", "Data Source:",
+                           choices = c("Upload CSV" = "upload", 
+                                       "Simulate data" = "simulate"),
+                           selected = "simulate"),
+              
+              conditionalPanel(
+                condition = "input.data_source == 'upload'",
+                fileInput("file_covariates", "Choose CSV File",
+                          accept = c(".csv")),
+                helpText("Columns = features/covariates, rows = units.")
+              ),
+              
+              conditionalPanel(
+                condition = "input.data_source == 'simulate'",
+                numericInput("sim_n", "Number of units (rows)", value = 20, min = 2),
+                numericInput("sim_p", "Number of covariates (columns)", value = 3, min = 1),
+                actionButton("simulate_btn", "Simulate X")
+              )
+          ),
+          
+          box(width = 7, title = "Preview of Covariates (X)",
+              status = "info", solidHeader = TRUE,
+              DTOutput("covariates_table"))
+        )
+      ),
+      
+      # ------------------------------------------------
+      # 2) Generate Randomizations Tab
+      # ------------------------------------------------
+      tabItem(
+        tabName = "gennet",
+        
+        fluidRow(
+          box(width = 4, title = "Rerandomization Parameters",
+              status = "primary", solidHeader = TRUE,
+              
+              # If user hasn't chosen data in tab 1, we fallback or show an error
+              numericInput("n_treated", "Number Treated (n_treated)", value = 10, min = 1),
+              selectInput("random_type", "Randomization Type:",
+                          choices = c("Monte Carlo" = "monte_carlo",
+                                      "Exact"        = "exact"),
+                          selected = "monte_carlo"),
+              numericInput("accept_prob", "Acceptance Probability (stringency)", 
+                           value = 0.05, min = 0.0001, max = 1),
+              conditionalPanel(
+                condition = "input.random_type == 'monte_carlo'",
+                numericInput("max_draws", "Max Draws (MC)", value = 1e4, min = 1e3),
+                numericInput("batch_size", "Batch Size (MC)", value = 1e3, min = 1e2)
+              ),
+              actionButton("generate_btn", "Generate Randomizations")
+          ),
+          
+          box(width = 8, title = "Summary of Accepted Randomizations",
+              status = "info", solidHeader = TRUE,
+              fluidRow(
+                valueBoxOutput("n_accepted_box", width = 6),
+                valueBoxOutput("balance_min_box", width = 6)
+              ),
+              br(),
+              plotOutput("balance_hist", height = "250px")
+          )
+        )
+      ),
+      
+      # ------------------------------------------------
+      # 3) Randomization Test Tab
+      # ------------------------------------------------
+      tabItem(
+        tabName = "randtest",
+        
+        fluidRow(
+          box(width = 4, title = "Randomization Test Setup",
+              status = "primary", solidHeader = TRUE,
+              
+              radioButtons("outcome_source", "Outcome Data (Y):",
+                           choices = c("Simulate Y" = "simulate",
+                                       "Upload CSV" = "uploadY"),
+                           selected = "simulate"),
+              
+              conditionalPanel(
+                condition = "input.outcome_source == 'simulate'",
+                numericInput("true_tau", "True Effect (simulate)", 1, step = 0.5),
+                numericInput("noise_sd", "Noise SD for Y", 0.5, step = 0.1),
+                actionButton("simulateY_btn", "Simulate Y")
+              ),
+              conditionalPanel(
+                condition = "input.outcome_source == 'uploadY'",
+                fileInput("file_outcomes", "Choose CSV File with outcome vector Y",
+                          accept = c(".csv")),
+                helpText("Single column with length = #units.")
+              ),
+              
+              br(),
+              actionButton("run_randtest_btn", "Run Randomization Test"),
+              checkboxInput("findFI", "Compute Fiducial Interval?", value = FALSE)
+          ),
+          
+          box(width = 8, title = "Test Results", status = "info", solidHeader = TRUE,
+              fluidRow(
+                valueBoxOutput("pvalue_box", width = 6),
+                valueBoxOutput("tauobs_box", width = 6)
+              ),
+              uiOutput("fi_text"),
+              br(),
+              plotOutput("test_plot", height = "280px")
+          )
+        )
+      )
+      
+    ) # end tabItems
+  ) # end dashboardBody
+) # end dashboardPage
 
+# ---------------------------------------------------------
+# SERVER
+# ---------------------------------------------------------
 server <- function(input, output, session) {
-  subsetted <- reactive({
-    req(input$species)
-    df |> filter(Species %in% input$species)
+  
+  # -------------------------------------------------------
+  # 1. Covariate Data Handling
+  # -------------------------------------------------------
+  # We store the covariate matrix X in a reactiveVal for convenient reuse 
+  X_data <- reactiveVal(NULL)
+  
+  # Observe file input or simulation for X
+  observeEvent(input$file_covariates, {
+    req(input$file_covariates)
+    inFile <- input$file_covariates
+    df <- tryCatch(read.csv(inFile$datapath, header = TRUE),
+                   error = function(e) NULL)
+    if (!is.null(df)) {
+      X_data(as.matrix(df))
+    }
   })
-
-  output$scatter <- renderPlot(
-    {
-      p <- ggplot(subsetted(), aes(!!input$xvar, !!input$yvar)) +
-        theme_light() +
-        list(
-          theme(legend.position = "bottom"),
-          if (input$by_species) aes(color = Species),
-          geom_point(),
-          if (input$smooth) geom_smooth()
-        )
-
-      if (input$show_margins) {
-        margin_type <- if (input$by_species) "density" else "histogram"
-        p <- p |> ggExtra::ggMarginal(
-          type = margin_type, margins = "both",
-          size = 8, groupColour = input$by_species, groupFill = input$by_species
-        )
+  
+  # If the user clicks "Simulate X"
+  observeEvent(input$simulate_btn, {
+    n <- input$sim_n
+    p <- input$sim_p
+    # Basic simulation of N(0,1) data
+    simX <- matrix(rnorm(n * p), nrow = n, ncol = p)
+    X_data(simX)
+  })
+  
+  # Show X in table
+  output$covariates_table <- renderDT({
+    req(X_data())
+    datatable(as.data.frame(X_data()), 
+              options = list(scrollX = TRUE, pageLength = 5))
+  })
+  
+  # -------------------------------------------------------
+  # 2. Generate Rerandomizations
+  # -------------------------------------------------------
+  # We'll keep the accepted randomizations in a reactiveVal
+  RerandResult <- reactiveVal(NULL)
+  
+  observeEvent(input$generate_btn, {
+    req(X_data())
+    validate(
+      need(nrow(X_data()) >= input$n_treated, 
+           "Number treated cannot exceed total units.")
+    )
+    
+    # We call generate_randomizations() from fastrerandomize
+    nunits <- nrow(X_data())
+    # If user selected "exact" but it's huge, a warning would appear in the console
+    out <- tryCatch({
+      generate_randomizations(
+        n_units                  = nunits,
+        n_treated                = input$n_treated,
+        X                        = X_data(),
+        randomization_accept_prob= input$accept_prob,
+        randomization_type       = input$random_type,
+        max_draws                = if (input$random_type == "monte_carlo") input$max_draws else NULL,
+        batch_size               = if (input$random_type == "monte_carlo") input$batch_size else NULL,
+        verbose                  = FALSE
+      )
+    }, error = function(e) e)
+    
+    if (inherits(out, "error")) {
+      showNotification(paste("Error generating randomizations:", out$message), type = "error")
+      return(NULL)
+    }
+    RerandResult(out)
+  })
+  
+  # Summaries of accepted randomizations
+  output$n_accepted_box <- renderValueBox({
+    rr <- RerandResult()
+    if (is.null(rr) || is.null(rr$randomizations)) {
+      valueBox("0", "Accepted Randomizations", icon = icon("ban"), color = "red")
+    } else {
+      nAcc <- nrow(rr$randomizations)
+      valueBox(nAcc, "Accepted Randomizations", icon = icon("check"), color = "green")
+    }
+  })
+  
+  output$balance_min_box <- renderValueBox({
+    rr <- RerandResult()
+    if (is.null(rr) || is.null(rr$balance)) {
+      valueBox("---", "Min Balance Measure", icon = icon("question"), color = "orange")
+    } else {
+      minBal <- round(min(rr$balance), 4)
+      valueBox(minBal, "Min Balance Measure", icon = icon("thumbs-up"), color = "blue")
+    }
+  })
+  
+  # Plot histogram of the balance measure
+  output$balance_hist <- renderPlot({
+    rr <- RerandResult()
+    req(rr, rr$balance)
+    df <- data.frame(balance = rr$balance)
+    ggplot(df, aes(x = balance)) +
+      geom_histogram(binwidth = diff(range(df$balance))/30, fill = "darkblue", alpha = 0.7) +
+      labs(title = "Distribution of Balance Measure",
+           x = "Balance (e.g. T^2)",
+           y = "Frequency") +
+      theme_minimal(base_size = 14)
+  })
+  
+  # -------------------------------------------------------
+  # 3. Randomization Test
+  # -------------------------------------------------------
+  Y_data <- reactiveVal(NULL)
+  
+  # (A) If user simulates Y
+  observeEvent(input$simulateY_btn, {
+    req(RerandResult())
+    rr <- RerandResult()
+    nunits <- nrow(rr$randomizations)
+    
+    # We'll just use the first accepted randomization as the "observed" assignment
+    # in real usage, they'd pick or define their actual assignment
+    obsW <- rr$randomizations[1, ]
+    
+    # Basic data generation: Y = X * beta + tau * W + noise
+    Xval <- X_data()
+    if (is.null(Xval)) {
+      showNotification("No covariate data found to help simulate outcomes. Using intercept-only model.", type="warning")
+      Xval <- matrix(0, nrow = nunits, ncol = 1)
+    }
+    # random coefficients
+    beta <- rnorm(ncol(Xval), 0, 1)
+    linear_part <- Xval %*% beta
+    Ysim <- as.numeric(linear_part + obsW*input$true_tau + rnorm(nunits, 0, input$noise_sd))
+    
+    Y_data(Ysim)
+  })
+  
+  # (B) If user uploads Y
+  observeEvent(input$file_outcomes, {
+    req(input$file_outcomes)
+    inFile <- input$file_outcomes
+    dfy <- tryCatch(read.csv(inFile$datapath, header = FALSE), error=function(e) NULL)
+    if (!is.null(dfy)) {
+      if (ncol(dfy) > 1) {
+        showNotification("Please provide a single-column CSV for Y.", type="error")
+      } else {
+        Y_data(as.numeric(dfy[[1]]))
       }
-
-      p
-    },
-    res = 100
-  )
+    }
+  })
+  
+  # The randomization test result:
+  RandTestResult <- reactiveVal(NULL)
+  
+  observeEvent(input$run_randtest_btn, {
+    req(RerandResult())
+    rr <- RerandResult()
+    req(rr$randomizations)
+    if (is.null(Y_data())) {
+      showNotification("No outcome data Y found. Upload or simulate first.", type="error")
+      return(NULL)
+    }
+    
+    # We'll do the test with:
+    obsW  <- rr$randomizations[1, ]
+    obsY  <- Y_data()
+    cands <- rr$randomizations
+    
+    if (length(obsY) != length(obsW)) {
+      showNotification("Dimension mismatch: Y must match number of units in the randomization.", type = "error")
+      return(NULL)
+    }
+    
+    # Call the randomization_test function
+    outTest <- tryCatch({
+      randomization_test(
+        obsW      = obsW,
+        obsY      = obsY,
+        candidate_randomizations = cands,
+        findFI    = input$findFI
+      )
+    }, error=function(e) e)
+    
+    if (inherits(outTest, "error")) {
+      showNotification(paste("Error in randomization_test:", outTest$message), type="error")
+      return(NULL)
+    }
+    
+    RandTestResult(outTest)
+  })
+  
+  # Display p-value and observed tau
+  output$pvalue_box <- renderValueBox({
+    rt <- RandTestResult()
+    if (is.null(rt)) {
+      valueBox("---", "p-value", icon = icon("question"), color = "blue")
+    } else {
+      valueBox(round(rt$p_value, 4), "p-value", icon = icon("list-check"), color = "purple")
+    }
+  })
+  
+  output$tauobs_box <- renderValueBox({
+    rt <- RandTestResult()
+    if (is.null(rt)) {
+      valueBox("---", "Observed Effect", icon = icon("question"), color = "maroon")
+    } else {
+      valueBox(round(rt$tau_obs, 4), "Observed Effect", icon = icon("bullseye"), color = "maroon")
+    }
+  })
+  
+  # If we have a fiducial interval, display it
+  output$fi_text <- renderUI({
+    rt <- RandTestResult()
+    if (is.null(rt) || is.null(rt$FI)) {
+      return(NULL)
+    }
+    fi_lower <- round(rt$FI[1], 4)
+    fi_upper <- round(rt$FI[2], 4)
+    
+    tagList(
+      strong("Fiducial Interval (95%):"),
+      p(sprintf("[%.4f, %.4f]", fi_lower, fi_upper))
+    )
+  })
+  
+  # A simple plot for the randomization distribution
+  output$test_plot <- renderPlot({
+    rt <- RandTestResult()
+    if (is.null(rt)) {
+      return(NULL)
+    }
+    # The distribution of test stats is stored in rt$stat_distribution if you used
+    #   advanced usage in the underlying code. The default version in 
+    #   randomization_test() above only returns the final p-value, so we'll do a
+    #   simpler demonstration: we only plot a vertical line for the observed effect.
+    
+    # We'll just do a line:
+    obs_val <- rt$tau_obs
+    
+    ggplot(data.frame(x=obs_val, y=0), aes(x, y)) +
+      geom_point(size=4, color="red") +
+      xlim(c(obs_val - abs(obs_val)*2 - 1, obs_val + abs(obs_val)*2 + 1)) +
+      labs(title = "Observed Treatment Effect", 
+           subtitle = "No randomization distribution stored to plot.\n(This is a minimal demonstration.)",
+           x = "Effect Size", y = "") +
+      theme_minimal(base_size = 14) +
+      geom_vline(xintercept = 0, linetype="dashed", color="gray40")
+  })
 }
 
-shinyApp(ui, server)
+# ---------------------------------------------------------
+# Run the Application
+# ---------------------------------------------------------
+shinyApp(ui = ui, server = server)