compileprofile-spacetests 0.3.0 → 0.4.0

package/dist/cjs/gonogo.js

@@ -1,4 +1,15 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.gonogo_results = exports.gonogo_extract_trials = exports.gonogo_calculate_results = void 0;
 var BEST_SCORE = 300;
@@ -9,49 +20,69 @@ var gonogo_calculate_results = function (data) {
     return results;
 };
 exports.gonogo_calculate_results = gonogo_calculate_results;
+// Which stimulus is "go" in each block of the runner:
+// 1 astronaut, 2 alien, 3 rocket, 4 anything but the rocket (the UFOs).
+var should_go_for = function (block_number, stimulus) {
+    switch (block_number) {
+        case 1: return stimulus == "astronaut_trans_1.png";
+        case 2: return stimulus == "alien_trans_1.png";
+        case 3: return stimulus == "rocket_trans_1.png";
+        case 4: return stimulus != "rocket_trans_1.png";
+        default: return false;
+    }
+};
 var gonogo_extract_trials = function (obj) {
-    // GONOGO_IMAGE_PATH <- "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/"
-    var trials = obj.filter(function (o) { return 'image' in o && o.image !== undefined; });
-    trials.forEach(function (o) {
-        // image is in format <stimulus>_trans_<number>.png
-        // "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/astronaut_trans_1.png",
-        var match = o.image.match(/([^/]+)_(\d+)\.png$/);
-        if (match) {
-            o.stimulus = match[0];
-            o.stimulustype = match[1];
-            o.image_number = match[2];
-        }
-        else {
+    var trials = [];
+    obj.filter(function (o) { return 'image' in o && o.image !== undefined && o.image !== null; }).forEach(function (o) {
+        // image is in format <stimulus>_trans_<number>.png, e.g.
+        // ".../test-stimuli/gonogo/aliens/astronaut_trans_1.png"
+        var match = String(o.image).match(/([^/]+)_(\d+)\.png$/);
+        if (!match) {
+            // Without a recognisable stimulus the trial cannot be scored, so leave it out
+            // instead of counting it as neither correct nor incorrect.
             console.warn('Image format did not match expected pattern:', o.image);
             return;
         }
-        o.should_go = false;
-        o.did_go = o.response !== null;
-        switch (o.block_number) {
-            case 1:
-                o.should_go = o.stimulus == "astronaut_trans_1.png";
-                break;
-            case 2:
-                o.should_go = o.stimulus == "alien_trans_1.png";
-                break;
-            case 3:
-                o.should_go = o.stimulus == "rocket_trans_1.png";
-                break;
-            case 4:
-                o.should_go = !(o.stimulus == "rocket_trans_1.png");
-                break;
-            default:
-                o.should_go = false;
-                break;
-        }
-        o.correct = o.should_go == o.did_go;
+        // Copy, so the caller's data is not modified.
+        var trial = __assign({}, o);
+        trial.stimulus = match[0];
+        trial.stimulustype = match[1];
+        trial.image_number = match[2];
+        // Prefer a go/no-go flag recorded by the runner; otherwise derive it from block and image.
+        trial.should_go = typeof o.should_go === 'boolean' ? o.should_go : should_go_for(o.block_number, trial.stimulus);
+        trial.did_go = o.response !== null && o.response !== undefined;
+        trial.correct = trial.should_go == trial.did_go;
+        trials.push(trial);
     });
     return trials;
 };
 exports.gonogo_extract_trials = gonogo_extract_trials;
-// TODO this
-var calculate_performance_score = function (avg_rt, avg_acc) {
-    var performance = avg_rt / (Math.pow(avg_acc, 5) + 0.001);
+var has_rt = function (o) { return o.did_go === true && typeof o.rt === 'number' && !isNaN(o.rt); };
+// Mean of the values; 0 for an empty list, so callers always get a number.
+var mean = function (values) { return values.length > 0 ? values.reduce(function (a, b) { return a + b; }, 0) / values.length : 0; };
+// Mean RT over the trials that have a response; trials without one have no RT and are not averaged in as 0.
+var mean_rt = function (trials) { return mean(trials.filter(has_rt).map(function (o) { return o.rt; })); };
+var proportion = function (trials, pred) {
+    return trials.length > 0 ? trials.filter(pred).length / trials.length : 0;
+};
+// Hit rate and correct-rejection rate weighted equally. When a set has no go (or no no-go)
+// trials, the other rate is used alone.
+var balanced_accuracy = function (go_trials, nogo_trials) {
+    var rates = [];
+    if (go_trials.length > 0)
+        rates.push(proportion(go_trials, function (o) { return o.correct === true; }));
+    if (nogo_trials.length > 0)
+        rates.push(proportion(nogo_trials, function (o) { return o.correct === true; }));
+    return mean(rates);
+};
+// Score 0-100 from the hit RT and the balanced accuracy: RT / (acc^5), clamped to 300-5000 ms.
+// Without any hit there is no RT to score, so the score is 0. (Previously an RT of 0 was
+// clamped to the best value, so a participant who never responded scored 100.)
+var calculate_performance_score = function (hit_rt, acc) {
+    if (!(hit_rt > 0)) {
+        return 0;
+    }
+    var performance = hit_rt / (Math.pow(acc, 5) + 0.001);
     performance = Math.min(Math.max(performance, BEST_SCORE), WORST_SCORE);
     var performance_score = (1 - ((performance - BEST_SCORE) / (WORST_SCORE - BEST_SCORE))) * 100;
     return performance_score;
@@ -63,51 +94,52 @@ var gonogo_results = function (data) {
     }
     var correct_trials = data.filter(function (o) { return o.correct === true; });
     var incorrect_trials = data.filter(function (o) { return o.correct === false; });
-    var missing_trials = []; // technically not possible in GNG, as no response is just incorrect
     var go_trials = data.filter(function (o) { return o.should_go === true; });
     var nogo_trials = data.filter(function (o) { return o.should_go === false; });
-    var total_rt = data.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
-    var correct_rt = correct_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
-    var incorrect_rt = incorrect_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
-    var responded_trials = data.filter(function (o) { return o.response !== null; });
-    var correct_responded_trials = responded_trials.filter(function (o) { return o.correct === true; });
-    var incorrect_responded_trials = responded_trials.filter(function (o) { return o.correct === false; });
-    var avg_rt = responded_trials.length > 0 ? total_rt / responded_trials.length : 0;
-    var avg_acc = correct_trials.length / data.length;
-    // Calculate performance score using the existing formula
-    var performance_score = calculate_performance_score(avg_rt, avg_acc);
+    // A response is correct on go trials (hit) and incorrect on no-go trials (false alarm).
+    // Correct no-go trials and missed go trials have no response, so no RT.
+    var hit_rt = mean_rt(go_trials);
+    var balanced_acc = balanced_accuracy(go_trials, nogo_trials);
     var common = {
         n_trials: data.length,
         n_correct_trials: correct_trials.length,
         n_incorrect_trials: incorrect_trials.length,
-        avg_rt_total: avg_rt,
-        avg_rt_correct: correct_trials.length > 0 ? correct_rt / correct_responded_trials.length : 0,
-        avg_rt_incorrect: incorrect_trials.length > 0 ? incorrect_rt / incorrect_responded_trials.length : 0,
-        performance_score: performance_score
+        avg_rt_total: mean_rt(data),
+        avg_rt_correct: mean_rt(correct_trials),
+        avg_rt_incorrect: mean_rt(incorrect_trials),
+        performance_score: calculate_performance_score(hit_rt, balanced_acc)
     };
     // Group by block for special results
     var by_block = Object.values(data.reduce(function (acc, trial) {
         var key = trial.block_number || 'unknown';
         if (!acc[key])
-            acc[key] = { block: key, trials: [], avg_rt: 0, avg_acc: 0 };
+            acc[key] = { block: key, trials: [] };
         acc[key].trials.push(trial);
         return acc;
     }, {})).map(function (group) {
-        group.avg_rt = group.trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / group.trials.length;
-        group.avg_acc = group.trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / group.trials.length;
+        var block_go = group.trials.filter(function (o) { return o.should_go === true; });
+        var block_nogo = group.trials.filter(function (o) { return o.should_go === false; });
+        group.avg_rt = mean_rt(block_go);
+        group.avg_acc = proportion(group.trials, function (o) { return o.correct === true; });
+        group.hit_rate = proportion(block_go, function (o) { return o.correct === true; });
+        group.correct_rejection_rate = proportion(block_nogo, function (o) { return o.correct === true; });
+        group.balanced_acc = balanced_accuracy(block_go, block_nogo);
         return group;
     });
     var special = {
+        balanced_acc: balanced_acc,
         by_block: by_block,
         go_trials: {
             n: go_trials.length,
-            avg_rt: go_trials.length > 0 ? go_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / go_trials.length : 0,
-            avg_acc: go_trials.length > 0 ? go_trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / go_trials.length : 0,
+            avg_rt: hit_rt,
+            avg_acc: proportion(go_trials, function (o) { return o.correct === true; }),
+            n_omissions: go_trials.filter(function (o) { return o.did_go === false; }).length,
         },
         nogo_trials: {
             n: nogo_trials.length,
-            avg_rt: nogo_trials.length > 0 ? nogo_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / nogo_trials.length : 0,
-            avg_acc: nogo_trials.length > 0 ? nogo_trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / nogo_trials.length : 0,
+            avg_rt: mean_rt(nogo_trials),
+            avg_acc: proportion(nogo_trials, function (o) { return o.correct === true; }),
+            n_commissions: nogo_trials.filter(function (o) { return o.did_go === true; }).length,
         }
     };
     return {

package/dist/cjs/nback.d.ts

@@ -1,5 +1,9 @@
-import { NbackResultsStructure } from './common-interfaces';
+import { NbackResultsStructure, NbackGroupResults, NbackBlockResults, NbackLevelResults } from './common-interfaces';
 declare const nback_calculate_results: (obj: any[]) => NbackResultsStructure;
 declare const nback_extract_trials: (obj: any[]) => any[];
 declare const nback_results: (trials: any[]) => NbackResultsStructure;
-export { nback_extract_trials, nback_results, nback_calculate_results, NbackResultsStructure };
+declare const inverse_normal: (p: number) => number;
+declare const nback_group_results: (trials: any[]) => NbackGroupResults;
+declare const nback_results_by_block: (trials: any[]) => NbackBlockResults[];
+declare const nback_results_by_nback: (trials: any[]) => NbackLevelResults[];
+export { nback_extract_trials, nback_results, nback_calculate_results, nback_group_results, nback_results_by_block, nback_results_by_nback, inverse_normal, NbackResultsStructure };

package/dist/cjs/nback.js

@@ -1,12 +1,33 @@
 "use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.nback_calculate_results = exports.nback_results = exports.nback_extract_trials = void 0;
+exports.inverse_normal = exports.nback_results_by_nback = exports.nback_results_by_block = exports.nback_group_results = exports.nback_calculate_results = exports.nback_results = exports.nback_extract_trials = void 0;
 // from the passed json extract those objects that have field is_target
+// Version 1 trials have no n_back field and get exactly the original result. Version 2 trials
+// (n_back, block, block_index on each trial) also get special.by_block and special.by_nback.
 var nback_calculate_results = function (obj) {
     var trials = nback_extract_trials(obj);
-    return nback_results(trials);
+    var results = nback_results(trials);
+    if (nback_is_versioned(trials)) {
+        results.special.by_block = nback_results_by_block(trials);
+        results.special.by_nback = nback_results_by_nback(trials);
+    }
+    return results;
 };
 exports.nback_calculate_results = nback_calculate_results;
+var nback_is_versioned = function (trials) {
+    return trials.some(function (t) { return t.n_back !== undefined && t.n_back !== null; });
+};
 var nback_extract_trials = function (obj) {
     var trials = obj.filter(function (o) { return 'is_target' in o; });
     return trials;
@@ -52,3 +73,112 @@ var nback_results = function (trials) {
     return results;
 };
 exports.nback_results = nback_results;
+// Standard normal CDF (Marsaglia 2004, Taylor series; absolute error ~1e-15 for |x| < 8)
+var normal_cdf = function (x) {
+    var sum = x, term = x, prev = 0;
+    var x2 = x * x;
+    for (var i = 3; sum !== prev; i += 2) {
+        prev = sum;
+        term *= x2 / i;
+        sum = prev + term;
+    }
+    return 0.5 + sum * Math.exp(-0.5 * x2 - 0.91893853320467274178);
+};
+// Inverse of the standard normal CDF: Acklam's rational approximation, polished with one
+// Halley step against normal_cdf, as Acklam recommends. Accurate to ~1e-12 for 1e-10 < p < 1 - 1e-10.
+var inverse_normal = function (p) {
+    if (p <= 0)
+        return -Infinity;
+    if (p >= 1)
+        return Infinity;
+    var x = acklam_inverse_normal(p);
+    var e = normal_cdf(x) - p;
+    var u = e * Math.sqrt(2 * Math.PI) * Math.exp(x * x / 2);
+    return x - u / (1 + x * u / 2);
+};
+exports.inverse_normal = inverse_normal;
+var acklam_inverse_normal = function (p) {
+    var a = [-3.969683028665376e+01, 2.209460984245205e+02, -2.759285104469687e+02,
+        1.383577518672690e+02, -3.066479806614716e+01, 2.506628277459239e+00];
+    var b = [-5.447609879822406e+01, 1.615858368580409e+02, -1.556989798598866e+02,
+        6.680131188771972e+01, -1.328068155288572e+01];
+    var c = [-7.784894002430293e-03, -3.223964580411365e-01, -2.400758277161838e+00,
+        -2.549671010322563e+00, 4.374664141464968e+00, 2.938163982698783e+00];
+    var d = [7.784695709041462e-03, 3.224671290700398e-01, 2.445134137142996e+00,
+        3.754408661907416e+00];
+    var p_low = 0.02425;
+    if (p < p_low) {
+        var q_1 = Math.sqrt(-2 * Math.log(p));
+        return (((((c[0] * q_1 + c[1]) * q_1 + c[2]) * q_1 + c[3]) * q_1 + c[4]) * q_1 + c[5]) /
+            ((((d[0] * q_1 + d[1]) * q_1 + d[2]) * q_1 + d[3]) * q_1 + 1);
+    }
+    if (p > 1 - p_low)
+        return -acklam_inverse_normal(1 - p);
+    var q = p - 0.5;
+    var r = q * q;
+    return (((((a[0] * r + a[1]) * r + a[2]) * r + a[3]) * r + a[4]) * r + a[5]) * q /
+        (((((b[0] * r + b[1]) * r + b[2]) * r + b[3]) * r + b[4]) * r + 1);
+};
+var mean_or_null = function (xs) {
+    return xs.length > 0 ? xs.reduce(function (s, x) { return s + x; }, 0) / xs.length : null;
+};
+var responded = function (t) { return t.response !== null && t.response !== undefined; };
+// d' uses the log-linear correction (Hautus 1995), so it stays finite at 0 % or 100 % rates
+var nback_group_results = function (trials) {
+    var targets = trials.filter(function (t) { return t.is_target; });
+    var non_targets = trials.filter(function (t) { return !t.is_target; });
+    var hits = targets.filter(responded);
+    var false_alarms = non_targets.filter(responded);
+    var lures = non_targets.filter(function (t) { return t.is_lure === true; });
+    var lure_false_alarms = lures.filter(responded).length;
+    var n_correct = trials.filter(function (t) { return t.correct === true; }).length;
+    var rts = function (ts) { return ts.map(function (t) { return t.rt; }).filter(function (rt) { return typeof rt === 'number'; }); };
+    return {
+        n_trials: trials.length,
+        n_correct_trials: n_correct,
+        performance_score: trials.length > 0 ? n_correct * 100 / trials.length : 0,
+        n_targets: targets.length,
+        n_non_targets: non_targets.length,
+        hits: hits.length,
+        misses: targets.length - hits.length,
+        false_alarms: false_alarms.length,
+        correct_rejections: non_targets.length - false_alarms.length,
+        hit_rate: targets.length > 0 ? hits.length / targets.length : null,
+        false_alarm_rate: non_targets.length > 0 ? false_alarms.length / non_targets.length : null,
+        d_prime: targets.length > 0 && non_targets.length > 0
+            ? inverse_normal((hits.length + 0.5) / (targets.length + 1))
+                - inverse_normal((false_alarms.length + 0.5) / (non_targets.length + 1))
+            : null,
+        n_lures: lures.length,
+        lure_false_alarms: lure_false_alarms,
+        lure_false_alarm_rate: lures.length > 0 ? lure_false_alarms / lures.length : null,
+        avg_rt_hits: mean_or_null(rts(hits)),
+        avg_rt_false_alarms: mean_or_null(rts(false_alarms)),
+    };
+};
+exports.nback_group_results = nback_group_results;
+var nback_results_by_block = function (trials) {
+    var blocks = new Map();
+    for (var _i = 0, trials_1 = trials; _i < trials_1.length; _i++) {
+        var t = trials_1[_i];
+        if (!blocks.has(t.block_index))
+            blocks.set(t.block_index, []);
+        blocks.get(t.block_index).push(t);
+    }
+    return Array.from(blocks.entries())
+        .sort(function (_a, _b) {
+        var a = _a[0];
+        var b = _b[0];
+        return a - b;
+    })
+        .map(function (_a) {
+        var block_index = _a[0], ts = _a[1];
+        return (__assign({ block: ts[0].block, block_index: block_index, n_back: ts[0].n_back }, nback_group_results(ts)));
+    });
+};
+exports.nback_results_by_block = nback_results_by_block;
+var nback_results_by_nback = function (trials) {
+    var levels = Array.from(new Set(trials.map(function (t) { return t.n_back; }))).sort(function (a, b) { return a - b; });
+    return levels.map(function (n_back) { return (__assign({ n_back: n_back }, nback_group_results(trials.filter(function (t) { return t.n_back === n_back; })))); });
+};
+exports.nback_results_by_nback = nback_results_by_nback;

package/dist/cjs/spatial-cognition.js

@@ -24,11 +24,9 @@ exports.spatial_extract_trials = spatial_extract_trials;
 var spatial_results = function (obj) {
     var correct_trials = obj.filter(function (o) { return o.correct === 1 || o.correct === true; });
     var incorrect_trials = obj.filter(function (o) { return o.correct === 0 || o.correct === false; });
-    var missing_trials = obj.filter(function (o) { return o.response === null || o.response === undefined; });
     var total_rt = obj.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
     var correct_rt = correct_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
     var incorrect_rt = incorrect_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
-    var missing_rt = missing_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
     var avg_rt = obj.length > 0 ? total_rt / obj.length : 0;
     var avg_acc = obj.length > 0 ? correct_trials.length / obj.length : 0;
     var performance_score = calculate_performance_score(avg_rt, avg_acc);

package/dist/esm/common-interfaces.d.ts

@@ -7,6 +7,33 @@ interface CommonResults {
     avg_rt_incorrect: number;
     performance_score: number;
 }
+interface NbackGroupResults {
+    n_trials: number;
+    n_correct_trials: number;
+    performance_score: number;
+    n_targets: number;
+    n_non_targets: number;
+    hits: number;
+    misses: number;
+    false_alarms: number;
+    correct_rejections: number;
+    hit_rate: number | null;
+    false_alarm_rate: number | null;
+    d_prime: number | null;
+    n_lures: number;
+    lure_false_alarms: number;
+    lure_false_alarm_rate: number | null;
+    avg_rt_hits: number | null;
+    avg_rt_false_alarms: number | null;
+}
+interface NbackBlockResults extends NbackGroupResults {
+    block: string;
+    block_index: number;
+    n_back: number;
+}
+interface NbackLevelResults extends NbackGroupResults {
+    n_back: number;
+}
 interface NbackSpecialResults {
     target_trials: {
         n: number;
@@ -18,6 +45,8 @@ interface NbackSpecialResults {
         avg_rt: number;
         avg_acc: number;
     };
+    by_block?: NbackBlockResults[];
+    by_nback?: NbackLevelResults[];
 }
 interface SpatialSpecialResults {
     by_distance: any[];
@@ -25,16 +54,19 @@ interface SpatialSpecialResults {
     by_rotation: any[];
 }
 interface GonogoSpecialResults {
+    balanced_acc: number;
     by_block: any[];
     go_trials: {
         n: number;
         avg_rt: number;
         avg_acc: number;
+        n_omissions: number;
     };
     nogo_trials: {
         n: number;
         avg_rt: number;
         avg_acc: number;
+        n_commissions: number;
     };
 }
 interface EmotionSpecialResults {
@@ -57,4 +89,4 @@ interface EmotionResultsStructure {
     common: CommonResults;
     special: EmotionSpecialResults;
 }
-export { CommonResults, NbackResultsStructure, SpatialResultsStructure, GonogoResultsStructure, EmotionResultsStructure, NbackSpecialResults, SpatialSpecialResults, GonogoSpecialResults, EmotionSpecialResults };
+export { CommonResults, NbackResultsStructure, SpatialResultsStructure, GonogoResultsStructure, EmotionResultsStructure, NbackSpecialResults, NbackGroupResults, NbackBlockResults, NbackLevelResults, SpatialSpecialResults, GonogoSpecialResults, EmotionSpecialResults };

package/dist/esm/gonogo.js

@@ -1,3 +1,14 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var BEST_SCORE = 300;
 var WORST_SCORE = 5000;
 var gonogo_calculate_results = function (data) {
@@ -5,48 +16,68 @@ var gonogo_calculate_results = function (data) {
     var results = gonogo_results(trials);
     return results;
 };
+// Which stimulus is "go" in each block of the runner:
+// 1 astronaut, 2 alien, 3 rocket, 4 anything but the rocket (the UFOs).
+var should_go_for = function (block_number, stimulus) {
+    switch (block_number) {
+        case 1: return stimulus == "astronaut_trans_1.png";
+        case 2: return stimulus == "alien_trans_1.png";
+        case 3: return stimulus == "rocket_trans_1.png";
+        case 4: return stimulus != "rocket_trans_1.png";
+        default: return false;
+    }
+};
 var gonogo_extract_trials = function (obj) {
-    // GONOGO_IMAGE_PATH <- "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/"
-    var trials = obj.filter(function (o) { return 'image' in o && o.image !== undefined; });
-    trials.forEach(function (o) {
-        // image is in format <stimulus>_trans_<number>.png
-        // "image": "https://unyavwofnmwihnpvkjji.supabase.co/storage/v1/object/public/test-stimuli/gonogo/aliens/astronaut_trans_1.png",
-        var match = o.image.match(/([^/]+)_(\d+)\.png$/);
-        if (match) {
-            o.stimulus = match[0];
-            o.stimulustype = match[1];
-            o.image_number = match[2];
-        }
-        else {
+    var trials = [];
+    obj.filter(function (o) { return 'image' in o && o.image !== undefined && o.image !== null; }).forEach(function (o) {
+        // image is in format <stimulus>_trans_<number>.png, e.g.
+        // ".../test-stimuli/gonogo/aliens/astronaut_trans_1.png"
+        var match = String(o.image).match(/([^/]+)_(\d+)\.png$/);
+        if (!match) {
+            // Without a recognisable stimulus the trial cannot be scored, so leave it out
+            // instead of counting it as neither correct nor incorrect.
             console.warn('Image format did not match expected pattern:', o.image);
             return;
         }
-        o.should_go = false;
-        o.did_go = o.response !== null;
-        switch (o.block_number) {
-            case 1:
-                o.should_go = o.stimulus == "astronaut_trans_1.png";
-                break;
-            case 2:
-                o.should_go = o.stimulus == "alien_trans_1.png";
-                break;
-            case 3:
-                o.should_go = o.stimulus == "rocket_trans_1.png";
-                break;
-            case 4:
-                o.should_go = !(o.stimulus == "rocket_trans_1.png");
-                break;
-            default:
-                o.should_go = false;
-                break;
-        }
-        o.correct = o.should_go == o.did_go;
+        // Copy, so the caller's data is not modified.
+        var trial = __assign({}, o);
+        trial.stimulus = match[0];
+        trial.stimulustype = match[1];
+        trial.image_number = match[2];
+        // Prefer a go/no-go flag recorded by the runner; otherwise derive it from block and image.
+        trial.should_go = typeof o.should_go === 'boolean' ? o.should_go : should_go_for(o.block_number, trial.stimulus);
+        trial.did_go = o.response !== null && o.response !== undefined;
+        trial.correct = trial.should_go == trial.did_go;
+        trials.push(trial);
     });
     return trials;
 };
-// TODO this
-var calculate_performance_score = function (avg_rt, avg_acc) {
-    var performance = avg_rt / (Math.pow(avg_acc, 5) + 0.001);
+var has_rt = function (o) { return o.did_go === true && typeof o.rt === 'number' && !isNaN(o.rt); };
+// Mean of the values; 0 for an empty list, so callers always get a number.
+var mean = function (values) { return values.length > 0 ? values.reduce(function (a, b) { return a + b; }, 0) / values.length : 0; };
+// Mean RT over the trials that have a response; trials without one have no RT and are not averaged in as 0.
+var mean_rt = function (trials) { return mean(trials.filter(has_rt).map(function (o) { return o.rt; })); };
+var proportion = function (trials, pred) {
+    return trials.length > 0 ? trials.filter(pred).length / trials.length : 0;
+};
+// Hit rate and correct-rejection rate weighted equally. When a set has no go (or no no-go)
+// trials, the other rate is used alone.
+var balanced_accuracy = function (go_trials, nogo_trials) {
+    var rates = [];
+    if (go_trials.length > 0)
+        rates.push(proportion(go_trials, function (o) { return o.correct === true; }));
+    if (nogo_trials.length > 0)
+        rates.push(proportion(nogo_trials, function (o) { return o.correct === true; }));
+    return mean(rates);
+};
+// Score 0-100 from the hit RT and the balanced accuracy: RT / (acc^5), clamped to 300-5000 ms.
+// Without any hit there is no RT to score, so the score is 0. (Previously an RT of 0 was
+// clamped to the best value, so a participant who never responded scored 100.)
+var calculate_performance_score = function (hit_rt, acc) {
+    if (!(hit_rt > 0)) {
+        return 0;
+    }
+    var performance = hit_rt / (Math.pow(acc, 5) + 0.001);
     performance = Math.min(Math.max(performance, BEST_SCORE), WORST_SCORE);
     var performance_score = (1 - ((performance - BEST_SCORE) / (WORST_SCORE - BEST_SCORE))) * 100;
     return performance_score;
@@ -58,51 +89,52 @@ var gonogo_results = function (data) {
     }
     var correct_trials = data.filter(function (o) { return o.correct === true; });
     var incorrect_trials = data.filter(function (o) { return o.correct === false; });
-    var missing_trials = []; // technically not possible in GNG, as no response is just incorrect
     var go_trials = data.filter(function (o) { return o.should_go === true; });
     var nogo_trials = data.filter(function (o) { return o.should_go === false; });
-    var total_rt = data.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
-    var correct_rt = correct_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
-    var incorrect_rt = incorrect_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0);
-    var responded_trials = data.filter(function (o) { return o.response !== null; });
-    var correct_responded_trials = responded_trials.filter(function (o) { return o.correct === true; });
-    var incorrect_responded_trials = responded_trials.filter(function (o) { return o.correct === false; });
-    var avg_rt = responded_trials.length > 0 ? total_rt / responded_trials.length : 0;
-    var avg_acc = correct_trials.length / data.length;
-    // Calculate performance score using the existing formula
-    var performance_score = calculate_performance_score(avg_rt, avg_acc);
+    // A response is correct on go trials (hit) and incorrect on no-go trials (false alarm).
+    // Correct no-go trials and missed go trials have no response, so no RT.
+    var hit_rt = mean_rt(go_trials);
+    var balanced_acc = balanced_accuracy(go_trials, nogo_trials);
     var common = {
         n_trials: data.length,
         n_correct_trials: correct_trials.length,
         n_incorrect_trials: incorrect_trials.length,
-        avg_rt_total: avg_rt,
-        avg_rt_correct: correct_trials.length > 0 ? correct_rt / correct_responded_trials.length : 0,
-        avg_rt_incorrect: incorrect_trials.length > 0 ? incorrect_rt / incorrect_responded_trials.length : 0,
-        performance_score: performance_score
+        avg_rt_total: mean_rt(data),
+        avg_rt_correct: mean_rt(correct_trials),
+        avg_rt_incorrect: mean_rt(incorrect_trials),
+        performance_score: calculate_performance_score(hit_rt, balanced_acc)
     };
     // Group by block for special results
     var by_block = Object.values(data.reduce(function (acc, trial) {
         var key = trial.block_number || 'unknown';
         if (!acc[key])
-            acc[key] = { block: key, trials: [], avg_rt: 0, avg_acc: 0 };
+            acc[key] = { block: key, trials: [] };
         acc[key].trials.push(trial);
         return acc;
     }, {})).map(function (group) {
-        group.avg_rt = group.trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / group.trials.length;
-        group.avg_acc = group.trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / group.trials.length;
+        var block_go = group.trials.filter(function (o) { return o.should_go === true; });
+        var block_nogo = group.trials.filter(function (o) { return o.should_go === false; });
+        group.avg_rt = mean_rt(block_go);
+        group.avg_acc = proportion(group.trials, function (o) { return o.correct === true; });
+        group.hit_rate = proportion(block_go, function (o) { return o.correct === true; });
+        group.correct_rejection_rate = proportion(block_nogo, function (o) { return o.correct === true; });
+        group.balanced_acc = balanced_accuracy(block_go, block_nogo);
         return group;
     });
     var special = {
+        balanced_acc: balanced_acc,
         by_block: by_block,
         go_trials: {
             n: go_trials.length,
-            avg_rt: go_trials.length > 0 ? go_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / go_trials.length : 0,
-            avg_acc: go_trials.length > 0 ? go_trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / go_trials.length : 0,
+            avg_rt: hit_rt,
+            avg_acc: proportion(go_trials, function (o) { return o.correct === true; }),
+            n_omissions: go_trials.filter(function (o) { return o.did_go === false; }).length,
         },
         nogo_trials: {
             n: nogo_trials.length,
-            avg_rt: nogo_trials.length > 0 ? nogo_trials.reduce(function (a, b) { return a + (b.rt || 0); }, 0) / nogo_trials.length : 0,
-            avg_acc: nogo_trials.length > 0 ? nogo_trials.reduce(function (a, b) { return a + (b.correct ? 1 : 0); }, 0) / nogo_trials.length : 0,
+            avg_rt: mean_rt(nogo_trials),
+            avg_acc: proportion(nogo_trials, function (o) { return o.correct === true; }),
+            n_commissions: nogo_trials.filter(function (o) { return o.did_go === true; }).length,
         }
     };
     return {

package/dist/esm/nback.d.ts

@@ -1,5 +1,9 @@
-import { NbackResultsStructure } from './common-interfaces';
+import { NbackResultsStructure, NbackGroupResults, NbackBlockResults, NbackLevelResults } from './common-interfaces';
 declare const nback_calculate_results: (obj: any[]) => NbackResultsStructure;
 declare const nback_extract_trials: (obj: any[]) => any[];
 declare const nback_results: (trials: any[]) => NbackResultsStructure;
-export { nback_extract_trials, nback_results, nback_calculate_results, NbackResultsStructure };
+declare const inverse_normal: (p: number) => number;
+declare const nback_group_results: (trials: any[]) => NbackGroupResults;
+declare const nback_results_by_block: (trials: any[]) => NbackBlockResults[];
+declare const nback_results_by_nback: (trials: any[]) => NbackLevelResults[];
+export { nback_extract_trials, nback_results, nback_calculate_results, nback_group_results, nback_results_by_block, nback_results_by_nback, inverse_normal, NbackResultsStructure };