@luminati-io/luminati-proxy/util/rand.js

A configurable local proxy for brightdata.com

// LICENSE_CODE ZON ISC
'use strict'; /*jslint node:true, browser:true*/
(function(){
var define;
var is_node = typeof module=='object' && module.exports && module.children;
if (!is_node)
    define = self.define;
else
    define = require('./require_node.js').define(module, '../');
define(['/util/array.js', '/util/date.js'], function(array, date){
var E = {};

var is_jtest = false;
var jtest_vals = {};
var MAX_INT = 2147483647;
var MIN_INT = -MAX_INT-1;

function jtest_pop(s){
    var elm;
    if (s===undefined)
        return null;
    if ((elm = jtest_vals[s])===undefined)
        return null;
    return elm.shift();
}

E.rand = function(s){
    var ret;
    if (is_jtest && (ret = jtest_pop(s))!==null)
        return ret;
    return Math.random();
};

E.rand_int32 = function(s){
    var ret;
    if (is_jtest && (ret = jtest_pop(s))!==null)
        return ret;
    return Math.floor(Math.random()*(MAX_INT-MIN_INT+1))-MAX_INT;
};

// return a random real number from [min, max)
E.rand_range_f = function(min, max, s){
    var ret;
    if (is_jtest && (ret = jtest_pop(s))!==null)
        return ret;
    return Math.random()*(max-min)+min;
};

// return a rand number from "min" to "max-1"
E.rand_range = function(min, max, s){
    var ret;
    if (is_jtest && (ret = jtest_pop(s))!==null)
        return ret;
    return Math.floor(Math.random()*(max-min))+min;
};

// return a rand point [x, y] from a quad
// quad=[x0, y0, x1, y1, x2, y2, x3, y3]
// assumes that area of 0-1-2 triangle is the same as 0-2-3
E.rand_in_quad = function(quad, s){
    var ret;
    if (is_jtest && (ret = jtest_pop(s))!==null)
        return ret;
    // select triangle
    var tri = Math.floor(Math.random()*2);
    var i0 = 0;
    var i1 = tri+1;
    var i2 = tri+2;
    var x0 = quad[2*i0], y0 = quad[2*i0+1];
    var x1 = quad[2*i1], y1 = quad[2*i1+1];
    var x2 = quad[2*i2], y2 = quad[2*i2+1];
    // gen barycentric coords
    var u = Math.random();
    var v = Math.random();
    if (u + v > 1)
    {
      u = 1-u;
      v = 1-v;
    }
    var w = 1 - u - v;
    return [
      u*x0 + v*x1 + w*x2,
      u*y0 + v*y1 + w*y2,
    ];
};

E.rand_element = function(a, s){
    if (a.length)
        return a[E.rand_range(0, a.length, s)];
};

E.rand_subset = function(a, size, s){
    // Fisher-Yates-Knuth shuffle
    var shuffled = a.slice(0);
    for (var i=0; i<size; i++)
    {
        var j = E.rand_range(i, shuffled.length, s);
        var tmp = shuffled[j];
        shuffled[j] = shuffled[i];
        shuffled[i] = tmp;
    }
    return shuffled.slice(0, size);
};

E.jtest_push = function(s, arr){
    if (!jtest_vals[s])
        jtest_vals[s] = [];
    if (Array.isArray(arr))
        array.push(jtest_vals[s], arr);
    else
        jtest_vals[s].push(arr);
};

E.jtest_init = function(){
    var i;
    is_jtest = true;
    jtest_vals = {};
    for (i=0; i<arguments.length; i++)
        E.jtest_push.apply(E, array.to_array(arguments[i]));
    return E.jtest_uninit.bind(E);
};

E.jtest_uninit = function(){
    is_jtest = false;
    jtest_vals = {};
};

E.basic_u32 = function(v){ return 1103515245*v+12345 >>> 0; };
E.basic_u31 = function(v){ return 1103515245*v+12345 & 0x7fffffff; };

var backoff_jitter_strategies = {
    full_jitter: function(base, cap, attempt){
        // using rand instead of rand_range to be able correctly use jtest
        return Math.round(
            E.rand('jitter')*Math.min(cap, base*Math.pow(2, attempt)));
    },
};
E.calc_exp_delay_with_jitter = function(attempt, opt){
    opt = opt||{};
    var base = opt.base||3*date.ms.SEC, cap = opt.cap||15*date.ms.SEC;
    var strategy = opt.strategy||'full_jitter';
    return backoff_jitter_strategies[strategy](base, cap, attempt);
};

return E; }); }());