think-bayes
Version:
An algorithm framework of probability and statistics for browser and Node.js environment.
230 lines (180 loc) • 8.84 kB
JavaScript
;
require("core-js/modules/es.symbol");
require("core-js/modules/es.symbol.description");
require("core-js/modules/es.symbol.iterator");
require("core-js/modules/es.array.iterator");
require("core-js/modules/es.array.map");
require("core-js/modules/es.array.sort");
require("core-js/modules/es.object.get-prototype-of");
require("core-js/modules/es.object.set-prototype-of");
require("core-js/modules/es.object.to-string");
require("core-js/modules/es.regexp.to-string");
require("core-js/modules/es.string.iterator");
require("core-js/modules/web.dom-collections.iterator");
Object.defineProperty(exports, "__esModule", {
value: true
});
exports.default = void 0;
var _Pmf2 = _interopRequireDefault(require("../Pmf"));
var _math = _interopRequireDefault(require("../math"));
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
function _slicedToArray(arr, i) { return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest(); }
function _nonIterableRest() { throw new TypeError("Invalid attempt to destructure non-iterable instance"); }
function _iterableToArrayLimit(arr, i) { if (!(Symbol.iterator in Object(arr) || Object.prototype.toString.call(arr) === "[object Arguments]")) { return; } var _arr = []; var _n = true; var _d = false; var _e = undefined; try { for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { _arr.push(_s.value); if (i && _arr.length === i) break; } } catch (err) { _d = true; _e = err; } finally { try { if (!_n && _i["return"] != null) _i["return"](); } finally { if (_d) throw _e; } } return _arr; }
function _arrayWithHoles(arr) { if (Array.isArray(arr)) return arr; }
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }
function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }
function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
/**
* Represents a joint distribution.
* The values are sequences (usually tuples)
* @param {string|array|object} values sequence of values
* @param {string} name sequence of values
*/
var Joint =
/*#__PURE__*/
function (_Pmf) {
_inherits(Joint, _Pmf);
function Joint() {
_classCallCheck(this, Joint);
return _possibleConstructorReturn(this, _getPrototypeOf(Joint).apply(this, arguments));
}
_createClass(Joint, [{
key: "marginal",
/**
* Gets the marginal distribution of the indicated variable.
* @param {number} i index of the variable we want
* @returns Pmf
*/
value: function marginal(i, name) {
var pmf = new _Pmf2.default(null, name);
var _iteratorNormalCompletion = true;
var _didIteratorError = false;
var _iteratorError = undefined;
try {
for (var _iterator = this.items()[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
var _step$value = _slicedToArray(_step.value, 2),
vs = _step$value[0],
prob = _step$value[1];
pmf.incr(vs[i], prob);
}
} catch (err) {
_didIteratorError = true;
_iteratorError = err;
} finally {
try {
if (!_iteratorNormalCompletion && _iterator.return != null) {
_iterator.return();
}
} finally {
if (_didIteratorError) {
throw _iteratorError;
}
}
}
return pmf;
}
/**
* Gets the conditional distribution of the indicated variable.
* Distribution of vs[i], conditioned on vs[j] = val.
* @param {number} i index of the variable we want
* @param {number} j which variable is conditioned on
* @param {*} val the value the jth variable has to have
* @returns Pmf
*/
}, {
key: "conditional",
value: function conditional(i, j, val, name) {
var pmf = new _Pmf2.default(null, name);
var _iteratorNormalCompletion2 = true;
var _didIteratorError2 = false;
var _iteratorError2 = undefined;
try {
for (var _iterator2 = this.items()[Symbol.iterator](), _step2; !(_iteratorNormalCompletion2 = (_step2 = _iterator2.next()).done); _iteratorNormalCompletion2 = true) {
var _step2$value = _slicedToArray(_step2.value, 2),
vs = _step2$value[0],
prob = _step2$value[1];
if (vs[j] !== val) continue;
pmf.incr(vs[i], prob);
}
} catch (err) {
_didIteratorError2 = true;
_iteratorError2 = err;
} finally {
try {
if (!_iteratorNormalCompletion2 && _iterator2.return != null) {
_iterator2.return();
}
} finally {
if (_didIteratorError2) {
throw _iteratorError2;
}
}
}
pmf.normalize();
return pmf;
}
/**
* Returns the maximum-likelihood credible interval.
* If percentage=90, computes a 90% CI containing the values
* with the highest likelihoods.
* @param {number} percentage float between 0 and 100
* @returns list of values from the suite
*/
}, {
key: "maxLikeInterval",
value: function maxLikeInterval() {
var percentage = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 90;
var interval = [];
var total = 0;
var t = this.items().map(function (_ref) {
var _ref2 = _slicedToArray(_ref, 2),
x = _ref2[0],
p = _ref2[1];
return [p, x];
}).sort(function (_ref3, _ref4) {
var _ref5 = _slicedToArray(_ref3, 1),
a = _ref5[0];
var _ref6 = _slicedToArray(_ref4, 1),
b = _ref6[0];
return _math.default.compare(b, a);
});
var _iteratorNormalCompletion3 = true;
var _didIteratorError3 = false;
var _iteratorError3 = undefined;
try {
for (var _iterator3 = t[Symbol.iterator](), _step3; !(_iteratorNormalCompletion3 = (_step3 = _iterator3.next()).done); _iteratorNormalCompletion3 = true) {
var _step3$value = _slicedToArray(_step3.value, 2),
prob = _step3$value[0],
val = _step3$value[1];
interval.push(val);
total = _math.default.add(total, prob);
if (total >= _math.default.div(percentage, 100)) break;
}
} catch (err) {
_didIteratorError3 = true;
_iteratorError3 = err;
} finally {
try {
if (!_iteratorNormalCompletion3 && _iterator3.return != null) {
_iterator3.return();
}
} finally {
if (_didIteratorError3) {
throw _iteratorError3;
}
}
}
return interval;
}
}]);
return Joint;
}(_Pmf2.default);
exports.default = Joint;
//# sourceMappingURL=index.js.map