compileprofile-spacetests 0.3.0 → 0.4.0

package/dist/esm/nback.js

@@ -1,7 +1,28 @@
+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);
+};
 // 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;
+};
+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; });
@@ -46,4 +67,109 @@ var nback_results = function (trials) {
     console.log(results);
     return results;
 };
-export { nback_extract_trials, nback_results, nback_calculate_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);
+};
+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)),
+    };
+};
+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)));
+    });
+};
+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; })))); });
+};
+export { nback_extract_trials, nback_results, nback_calculate_results, nback_group_results, nback_results_by_block, nback_results_by_nback, inverse_normal };

package/dist/esm/spatial-cognition.js

@@ -19,11 +19,9 @@ var spatial_extract_trials = function (obj) {
 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);