diff --git a/.nojekyll b/.nojekyll
index 601166ae..82f5b772 100644
--- a/.nojekyll
+++ b/.nojekyll
@@ -1 +1 @@
-fdd0a3de
\ No newline at end of file
+dde62fe1
\ No newline at end of file
diff --git a/R/readme.html b/R/readme.html
index 5a6a0569..a44fd047 100644
--- a/R/readme.html
+++ b/R/readme.html
@@ -35,10 +35,12 @@
-
+
+
-
+
+
-
+
+
-
+
+
+
+
As you can see, the data-frame contains the column GRADE_CRITERIA_CODE which contains comparisons of floating point values. And there was a discrepancy of what Gordon expected to see, and how R actually computed the comparison initially:
As you can see, the data-frame contains the column GRADE_CRITERIA_CODE which contains comparisons of floating point values. And there was a discrepancy of what Gordon expected to see, and how R actually computed the comparison initially:
}
}
toggleBodyColorPrimary();
+ const disableStylesheet = (stylesheets) => {
+ for (let i=0; i < stylesheets.length; i++) {
+ const stylesheet = stylesheets[i];
+ stylesheet.rel = 'prefetch';
+ }
+ }
+ const enableStylesheet = (stylesheets) => {
+ for (let i=0; i < stylesheets.length; i++) {
+ const stylesheet = stylesheets[i];
+ stylesheet.rel = 'stylesheet';
+ }
+ }
+ const manageTransitions = (selector, allowTransitions) => {
+ const els = window.document.querySelectorAll(selector);
+ for (let i=0; i < els.length; i++) {
+ const el = els[i];
+ if (allowTransitions) {
+ el.classList.remove('notransition');
+ } else {
+ el.classList.add('notransition');
+ }
+ }
+ }
+ const toggleColorMode = (alternate) => {
+ // Switch the stylesheets
+ const alternateStylesheets = window.document.querySelectorAll('link.quarto-color-scheme.quarto-color-alternate');
+ manageTransitions('#quarto-margin-sidebar .nav-link', false);
+ if (alternate) {
+ enableStylesheet(alternateStylesheets);
+ for (const sheetNode of alternateStylesheets) {
+ if (sheetNode.id === "quarto-bootstrap") {
+ toggleBodyColorMode(sheetNode);
+ }
+ }
+ } else {
+ disableStylesheet(alternateStylesheets);
+ toggleBodyColorPrimary();
+ }
+ manageTransitions('#quarto-margin-sidebar .nav-link', true);
+ // Switch the toggles
+ const toggles = window.document.querySelectorAll('.quarto-color-scheme-toggle');
+ for (let i=0; i < toggles.length; i++) {
+ const toggle = toggles[i];
+ if (toggle) {
+ if (alternate) {
+ toggle.classList.add("alternate");
+ } else {
+ toggle.classList.remove("alternate");
+ }
+ }
+ }
+ // Hack to workaround the fact that safari doesn't
+ // properly recolor the scrollbar when toggling (#1455)
+ if (navigator.userAgent.indexOf('Safari') > 0 && navigator.userAgent.indexOf('Chrome') == -1) {
+ manageTransitions("body", false);
+ window.scrollTo(0, 1);
+ setTimeout(() => {
+ window.scrollTo(0, 0);
+ manageTransitions("body", true);
+ }, 40);
+ }
+ }
+ const isFileUrl = () => {
+ return window.location.protocol === 'file:';
+ }
+ const hasAlternateSentinel = () => {
+ let styleSentinel = getColorSchemeSentinel();
+ if (styleSentinel !== null) {
+ return styleSentinel === "alternate";
+ } else {
+ return false;
+ }
+ }
+ const setStyleSentinel = (alternate) => {
+ const value = alternate ? "alternate" : "default";
+ if (!isFileUrl()) {
+ window.localStorage.setItem("quarto-color-scheme", value);
+ } else {
+ localAlternateSentinel = value;
+ }
+ }
+ const getColorSchemeSentinel = () => {
+ if (!isFileUrl()) {
+ const storageValue = window.localStorage.getItem("quarto-color-scheme");
+ return storageValue != null ? storageValue : localAlternateSentinel;
+ } else {
+ return localAlternateSentinel;
+ }
+ }
+ let localAlternateSentinel = 'default';
+ // Dark / light mode switch
+ window.quartoToggleColorScheme = () => {
+ // Read the current dark / light value
+ let toAlternate = !hasAlternateSentinel();
+ toggleColorMode(toAlternate);
+ setStyleSentinel(toAlternate);
+ };
+ // Ensure there is a toggle, if there isn't float one in the top right
+ if (window.document.querySelector('.quarto-color-scheme-toggle') === null) {
+ const a = window.document.createElement('a');
+ a.classList.add('top-right');
+ a.classList.add('quarto-color-scheme-toggle');
+ a.href = "";
+ a.onclick = function() { try { window.quartoToggleColorScheme(); } catch {} return false; };
+ const i = window.document.createElement("i");
+ i.classList.add('bi');
+ a.appendChild(i);
+ window.document.body.appendChild(a);
+ }
+ // Switch to dark mode if need be
+ if (hasAlternateSentinel()) {
+ toggleColorMode(true);
+ } else {
+ toggleColorMode(false);
+ }
const icon = "";
const anchorJS = new window.AnchorJS();
anchorJS.options = {
diff --git a/posts/2023-11-27_higher_order/higher_order.html b/posts/2023-11-27_higher_order/higher_order.html
index a1bd1d6c..a765ae56 100644
--- a/posts/2023-11-27_higher_order/higher_order.html
+++ b/posts/2023-11-27_higher_order/higher_order.html
@@ -72,10 +72,12 @@
-
+
+
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
admiral 1.0.0
+
+
+ 1.0.0 brings a commitment to stability, new features, a few bug fixes, argument alignment and onboarding resources!
+
+
+
+
admiral
+
ADaMs
+
+
+
+
+
+
+
+
+
Author
+
+
Ben Straub
+
+
+
+
+
Published
+
+
January 4, 2024
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
admiral 1.0.0 is out on CRAN. This release brings several new features to your tool set for working with ADaMs in R. admiral 1.0.0 also brings needed stability to users who were wishing to adopt admiral, but were a little worried by the fast deprecation and experimentation for pre-v1.0.0 releases.
+
This blog post will discuss our commitment to stability, walk you through the new features available, discuss some of the bug fixes, a push for common APIs across our functions, and showcase the resources available to help you on-board to admiral.
+
+
Commitment to Stability
+
{admiral} was born out of a conversation between Thomas Neitmann and Michael Rimler almost three years ago. Check out this history blog post for some of additional context on its development. Over the last three years, we have worked at a furious pace to produce functions that can do almost all derivations needed for common ADaMs. However, we have noticed that some functions are very similar to others and with some minor tweaks could be made redundant in favor of other functions. This has lead to some deprecation of either whole functions or arguments as we have sought to consolidate. Unfortunately, this creates a lot of frustration for users.
+
Enter Superseded!!
+
Now with the release of 1.0.0 we are going to supersede functions going forward. This is the process where when we introduce new functions to replace other functions, we will no longer fast-deprecate the replaced functions. Now we will supersede them, i.e. we will keep the function in the codebase for a long time, but recommend the use of the new function. If the function were to be removed from the codebase this will be done many years from the time it is superseded. Please note that although superseded functions are not in scope for active development, any bugs identified within them will nevertheless be fixed.
+
+
+
New Features
+
We have 3 new functions available in this release:
This function takes available records from user-defined events by selecting the extreme observations and appending them as a variable(s) to your dataset. derive_vars_extreme_event() works similar to derive_extreme_event(), but instead of adding observations the function will add variable(s).
+
Let’s take a peek with a very simple example where we just use ADSL! The documentation for derive_vars_extreme_event() has a much richer example with events from other domains that is more aligned to where you would use this function.
+
Let us make some dummy ADSL data and load up our packages. The goal here is to add two new variables LSTALVDT and DTHFL based on a list of objects that are used to specify the following:
In this example, we only use ADSL as the source dataset, so it is a bit contrived, but much more compact for us. Note the use of the events that is taking in our list of event objects and the different conditions and values we set to create our LSTALVDT and DTHFL variables.
# A tibble: 5 × 6
+ STUDYID USUBJID TRTEDT DTHDT LSTALVDT DTHFL
+ <chr> <chr> <date> <date> <date> <chr>
+1 PILOT01 01-1130 2014-08-16 2014-09-13 2014-09-13 Y
+2 PILOT01 01-1133 2013-04-28 NA 2013-04-28 N
+3 PILOT01 01-1211 2013-01-12 NA 2013-01-12 N
+4 PILOT01 09-1081 2014-04-27 NA 2014-04-27 N
+5 PILOT01 09-1088 2014-10-09 2014-11-01 2014-11-01 Y
+
+
+
Okay! We used a very small example to showcase how to find extreme observations and appending this information as new variables to our ADSL dataset. Highly recommend checking out the more detailed example in the function documentation to see its true power!
+
+
+
derive_var_merged_ef_msrc()
+
This function has some similarity to derive_vars_extreme_event(), but now we are only looking at adding a single flag variable based on checking conditions across multiple datasets.
+
We develop some simple dummy data for ADSL, CM and PR. Our goal is to flag patients who have CMCAT = "ANTI-CANCER" in the CM dataset or have records in the PR dataset. Any participants who meet these conditions will have our new variable CANCTRFL set as "Y".
# A tibble: 4 × 2
+ USUBJID CANCTRFL
+ <chr> <chr>
+1 1 Y
+2 2 Y
+3 3 Y
+4 4 <NA>
+
+
+
Let’s go! We searched over multiple datasets, CM and PR, with multiple conditions and appended a new variable CANCTRFL to ADSL setting to "Y" if those conditions were met.
+
+
+
derive_vars_computed()
+
This function is very similar to derive_param_computed(), but instead of adding observations we are going to add variable(s). Very handy when wanting to add some additional variables to ADSL, e.g. baseline variables.
+
Let’s make some dummy data for an ADSL and ADVS. Our goal is to derive a BMIBL variable pulled from ADVS and append to ADSL.
Take a look at how we use new_vars and filter_add. We use a function inside of new_vars to help us calculate the BMI while using the filter_add argument to only look at baseline records for the calculation.
# A tibble: 2 × 5
+ STUDYID USUBJID AGE AGEU BMIBL
+ <chr> <chr> <dbl> <chr> <dbl>
+1 PILOT01 01-1302 61 YEARS 26.0
+2 PILOT01 17-1344 64 YEARS 21.7
+
+
+
Alright! Simple enough. We just took records from ADVSto help us calculate the BMI at baseline using this function and appended our new variable to ADSL.
+
+
+
+
Argument Alignment and Bug Fixes
+
+
Argument Alignment
+
A huge push was made for 1.0.0 to help align our arguments across all of {admiral} functions. What does this mean? We identified arguments in functions where the argument did the same things but was slightly named differently. For 1.0.0, we really want users to have a solid API for {admiral} functions.
+
Let’s take a peak at the function consolidate_metadata() to even better understand our goal here.
In previous versions of {admiral} the consolidate_metadata() function had the argument check_keys, which helps to check uniqueness. Other functions had a similar argument, but were called check_unique. Therefore, to better align our common API for {admiral} functions we decided to rename the check_keys argument to check_unique. You can follow the discussion around this renaming effort in this GitHub Issue.
+
+
+
+
+
+
+
+
+
+
The argument has a deprecated tag in the function documentation and will issue a warning to users. There was quite a bit of renaming of arguments for 1.0.0 so there are quite a few of these tags in our documentation. In subsequent releases, these arguments will be removed. Please see the changelog if you would like to explore other functions that had arguments renamed. The issues are linked to each rename so you can follow along with the discussions!
+
+
+
Bug Fixes
+
We love fixing bugs and take them incredibly seriously - especially when identified by members from the community.
+
If you find a pesky bug, please fill out a Bug Report on our Issues Tab.
+
Each bug fixed by our development team is documented in our changelog with the Issue linked.
+
+
+
+
+
+
+
+
+
+
For example, if you click through the issue for derive_extreme_event() that identified a problem where the condition was ignored if the mode argument was used, you can see the Bug Report along with a reproducible example. You can also see the Pull Request for the exact code changes that are addressing this bug linked in the Issue! Way cool!
+
+
+
+
New On-boarding Resources
+
{admiral} has a lot of functions for working with ADaMs. This can be overwhelming for new users and we really sympathize. To help new users onboarding to {admiral} we have developed the following resources:
This is a dedicated website that lists out in a tabular format standard ADaM datasets and their common variables with corresponding {admiral} functions that could be used to create the variables. Very handy when you just want to get some starter code on deriving EOSDT or TRTSDT!
Inspired by other R package cheat sheets! We try and surface commonly needed functions for doing ADaM derivations with simple tables to show how the data is transforming.
+
+
+
+
+
+
+
+
+
+
+
+
Way Back Machine
+
Studies can last a long time. Adopting R as your primary analysis language for your study can introduce certain risks around package dependencies. Fixing those dependencies to certain package versions can help mitigate those risks. Unfortunately, as package websites are updated those helpful documents, examples and vignettes can be lost as the version changes. Do not lose heart {admiral} users. If you decided to fix to a certain version of {admiral}, we have you covered with our Way Back Machine that allows you to change the website documentation back to the version you are using.
