(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
/**
* ToolsForFieldLinguistics
* A collection of scripts and recpies for fieldlinguistics and for RAs in data heavy labs
*
* https://github.com/cesine/ToolsForFieldLinguistics
*
* Copyright (c) 2010-2019 cesine
* Licensed under the Apache 2.0 license.
*
* @module ToolsForFieldLinguistics
* @tutorial test/javascript/ToolsForFieldLinguistics-spec.js
* @requires GenerateData
*/
var GenerateData = require("./data-manipulation/generate-data");
(function(exports) {
"use strict";
exports.init = function() {
return "init";
};
exports.GenerateData = GenerateData;
}(typeof exports === "object" && exports || this));
},{"./data-manipulation/generate-data":2}],2:[function(require,module,exports){
/**
* Utilities for generating (random) data for benchmarking and
* exploring data.
*
*
* @module GenerateData
* @extends {AnyObject}
* @tutorial test/javascript/generate-data-spec.js
* @param exports Object this is the object which will recieve the exports of this file
*/
(function(exports) {
"use strict";
var debug = function() {
// console.log(arguments);
return;
};
/**
* Fisher–Yates shuffling is similar to randomly picking numbered tickets
* (combinatorics: distinguishable objects) out of a hat without
* replacement until there are none left. <p>
*
* It was reduced to run in linear O(n) time by Durstenfeld 1964 by looping through
* the array just once O(n) and at each index, finding a random other index in the
* array to swap places with.
*
<pre>
Pseudocode
for i from n − 1 downto 1 do
j ← random integer with 0 ≤ j ≤ i
exchange a[j] and a[i]
</pre>
* @param {Array} shuffleMe An array to be shuffled
* @return {this} This, for chaining other operations.
*/
exports.shuffle = function shuffle(shuffleMe) {
for (var i = 0; i < shuffleMe.length; i++) {
var j = Math.floor((Math.random() * i));
var temp = shuffleMe[j];
shuffleMe[j] = shuffleMe[i];
shuffleMe[i] = temp;
}
return this;
};
/**
* Create an array of random numbers can be used to create data which can be reused later for
* debugging sorting algorithms and improving the runtime of your data crunching. <p>
*
* If you want to have unique integers, see createArrayOfRandomUniqueIntegers below.
*
*
* @param {int} n The size of the array to be creatd
* @param {int} start An optional minimal value, otherwise assumed to be 0
* @param {int} end An optional maximal value, otherwise assumed to be n
* @return {Array} An array of random unique integers
*/
exports.createArrayOfRandomIntegers = function(n, start, end) {
if (!n || n < 0) {
throw "n Must be a positive integer indicating the size of the array to be created";
}
start = start || 0;
end = end || n;
var randomSize = end - start + 1;
var ints = [];
for (var i = 0; i < n; i++) {
ints.push(Math.floor(Math.random() * randomSize) + start);
}
debug("\tRandom n:" + n + " start:" + start + " end:" + end + " result:");
debug("\t" + ints.length < 40 ? ints : "(too big)");
return ints;
};
/**
* Create an array of random unique numbers can be used to create data which can be reused later for
* debugging sorting algorithms and improving the runtime of your data crunching.
*
*
* @param {int} n The size of the array to be creatd
* @param {int} start An optional minimal value, otherwise assumed to be 0
* @param {int} end An optional maximal value, otherwise assumed to be n
* @return {Array} An array of random unique integers
*/
exports.createArrayOfRandomUniqueIntegers = function(n, start, end) {
if (!n || n < 0) {
throw "n Must be a positive integer indicating the size of the array to be created";
}
start = start || 0;
end = end || n;
/* Generate an array containing all the acceptable integers */
var ints = [];
for (var i = start; i <= end; i++) {
ints.push(i);
}
/* Suffle the array */
this.shuffle(ints);
/* Truncate the array to only the requested size n */
ints = ints.splice(0, n);
debug("\tUnique n:" + n + " start:" + start + " end:" + end + " result:");
debug("\t" + ints.length < 40 ? ints : "(too big)");
return ints;
};
/**
* This is an interesting approach to a unique problem. If you need to
* sort a dense set of random integers who are only unique (or you don't
* mind if you only get unique one back) then you can think of the integers
* not as an array of integers, but more like a bitmap where 0 if the integer
* is not present, and 1 if it is present. <p>
*
* In this way the datastruture causes the data to
* be sorted. What is interesting with this approach is that it shows how a
* datastructure can be leveraged to reduce runtime.<p>
*
* References: Bently 1986
*
* @param {Array} sortMe An array of random integers
* @param {int} minValue An optional smallest value in the input array, otherwise assumed to be 0
* @param {int} maxValue An optional largest value in the input array, otherwise assumed to be the size of sortMe
* @return {Array} A sorted array of unique integers which were in sortMe
*/
exports.sortRandomUniqueIntegers = function(sortMe, minValue, maxValue) {
if (!sortMe) {
throw "Cant sort: please pass an array to be sorted";
}
if (sortMe.length === 0 || sortMe.length === 1) {
return sortMe;
}
/* assume the highest value is provided, or is the size of the array to be sorted
* TOOD maybe pickup the min and max from step 2 since this is javascript?
*/
maxValue = maxValue || sortMe.length;
minValue = minValue || 0;
/* catch edge cases */
if (minValue > maxValue) {
throw "Cant sort: min:" + minValue + " is not less than max:" + maxValue;
}
if (minValue === maxValue) {
return [minValue];
}
/* Step 1: initialize the integer space to 0:notfound for all possible ints (unnecesary in javascript)
for (var i = minValue; i <= maxValue; i++) {
bitMap[i] = 0;
}
*/
var bitMap = {};
/* Step 2: if i is in the array, then set its bit to 1:found */
for (var i = 0, l = sortMe.length; i < l; i++) {
bitMap[sortMe[i]] = 1;
}
// debug(bitMap);
var result = [];
var sparsityMeasure = 0;
/* Step 3: convert the bitmap back into an array of integers */
for (var j = minValue; j <= maxValue; j++) {
if (bitMap[j] === 1) {
result.push(j);
// debug(i);
sparsityMeasure++;
}
}
var range = maxValue - minValue;
debug("\tSort n:" + sortMe.length + " start:" + minValue + " end:" + maxValue + " Sparsity: " + sparsityMeasure / range * 100);
return result;
};
exports.measureRunTime = function(measureMe, args, runtimeHolder) {
var start = Date.now();
var result = measureMe.apply(this, args);
runtimeHolder.runtime = Date.now() - start;
debug("Runtime: " + runtimeHolder.runtime);
return result;
};
exports.getUnique = function() {
var unique = {}, a = [];
for (var i = 0, l = this.length; i < l; ++i) {
if (unique.hasOwnProperty(this[i])) {
continue;
}
a.push(this[i]);
unique[this[i]] = 1;
}
return a;
};
}(typeof exports === "object" && exports || this));
},{}]},{},[1]);