>>> jukesCantorD(.1)
    (0.10732563273050497, 0.001198224852071006)
    >>> jukesCantorD(.7)
    (2.0310376508266565, 0.47249999999999864)
193788
def jukesCantorD(p, L=100):
    
    assert 0 <= p < .75

    rD = 1 - 4. / 3 * p
    D = -.75 * log(rD)
    varD = p * (1 - p) / (rD ** 2 * L)

    return D, varD
1063341
def mjd2gmst(mjd):
    """"""
    
    D2PI= 6.2831853071795864769252867665590057683943387987502
    DS2R= 7.2722052166430399038487115353692196393452995355905e-5
    
    tu = (mjd-51544.5)/36525.0;
    
    st = fmod(mjd,1.0) * D2PI + ( 24110.54841 + ( 8640184.812866 + ( 0.093104 - 6.2e-6 * tu ) * tu ) * tu ) * DS2R 
    
    w = fmod(st,D2PI)
    if w >= 0.0 :
        return w
    else:
        return w+D2PI
913207
function(timeStamp) {
        var secondsPerStamp = 1.001,
            timesplit = timeStamp.split(':'),
            timestampSeconds = (parseInt(timesplit[0], 10) * 3600 +
                parseInt(timesplit[1], 10) * 60 +
                parseInt(timesplit[2], 10) +
                parseInt(timesplit[3], 10) / 30),
            seconds = timestampSeconds * secondsPerStamp,
            microSeconds = seconds * 1000 * 1000;
        return (microSeconds > 0) ? microSeconds : 0;
    }
1052097
function p_t(df, t) {
        var c2, s, p, i;

        c2 = df / (df + t * t);
        s = Math.sqrt(1.0 - c2);

        if (t < 0.0) { s = -s; }

        p = 0.0;
        i = df % 2 + 2;
        while (i <= df) {
            p = p + s;
            s = s * ((i - 1) * c2 / i);
            i = i + 2;
        }

        if ((df & 1) !== 0) {
            return 0.5 + (p * Math.sqrt(c2) + Math.atan(t / Math.sqrt(df))) / Math.PI;
        }

        return (1.0 + p) / 2.0;
    }
96892
function(x,y){
        x[y>>5] |= 0x80<<((y)%32);
        x[(((y+64)>>>9)<<4)+14] = y;
        var a = 1732584193,
            b = -271733879,
            c = -1732584194,
            d = 271733878;
        for(var i=0,l=x.length,_oa,_ob,_oc,_od;i<l;i+=16){
            _oa = a; _ob = b; _oc = c; _od = d;
            a = __md5ff(a, b, c, d, x[i+ 0], 7 , -680876936);
            d = __md5ff(d, a, b, c, x[i+ 1], 12, -389564586);
            c = __md5ff(c, d, a, b, x[i+ 2], 17,  606105819);
            b = __md5ff(b, c, d, a, x[i+ 3], 22, -1044525330);
            a = __md5ff(a, b, c, d, x[i+ 4], 7 , -176418897);
            d = __md5ff(d, a, b, c, x[i+ 5], 12,  1200080426);
            c = __md5ff(c, d, a, b, x[i+ 6], 17, -1473231341);
            b = __md5ff(b, c, d, a, x[i+ 7], 22, -45705983);
            a = __md5ff(a, b, c, d, x[i+ 8], 7 ,  1770035416);
            d = __md5ff(d, a, b, c, x[i+ 9], 12, -1958414417);
            c = __md5ff(c, d, a, b, x[i+10], 17, -42063);
            b = __md5ff(b, c, d, a, x[i+11], 22, -1990404162);
            a = __md5ff(a, b, c, d, x[i+12], 7 ,  1804603682);
            d = __md5ff(d, a, b, c, x[i+13], 12, -40341101);
            c = __md5ff(c, d, a, b, x[i+14], 17, -1502002290);
            b = __md5ff(b, c, d, a, x[i+15], 22,  1236535329);
            a = __md5gg(a, b, c, d, x[i+ 1], 5 , -165796510);
            d = __md5gg(d, a, b, c, x[i+ 6], 9 , -1069501632);
            c = __md5gg(c, d, a, b, x[i+11], 14,  643717713);
            b = __md5gg(b, c, d, a, x[i+ 0], 20, -373897302);
            a = __md5gg(a, b, c, d, x[i+ 5], 5 , -701558691);
            d = __md5gg(d, a, b, c, x[i+10], 9 ,  38016083);
            c = __md5gg(c, d, a, b, x[i+15], 14, -660478335);
            b = __md5gg(b, c, d, a, x[i+ 4], 20, -405537848);
            a = __md5gg(a, b, c, d, x[i+ 9], 5 ,  568446438);
            d = __md5gg(d, a, b, c, x[i+14], 9 , -1019803690);
            c = __md5gg(c, d, a, b, x[i+ 3], 14, -187363961);
            b = __md5gg(b, c, d, a, x[i+ 8], 20,  1163531501);
            a = __md5gg(a, b, c, d, x[i+13], 5 , -1444681467);
            d = __md5gg(d, a, b, c, x[i+ 2], 9 , -51403784);
            c = __md5gg(c, d, a, b, x[i+ 7], 14,  1735328473);
            b = __md5gg(b, c, d, a, x[i+12], 20, -1926607734);
            a = __md5hh(a, b, c, d, x[i+ 5], 4 , -378558);
            d = __md5hh(d, a, b, c, x[i+ 8], 11, -2022574463);
            c = __md5hh(c, d, a, b, x[i+11], 16,  1839030562);
            b = __md5hh(b, c, d, a, x[i+14], 23, -35309556);
            a = __md5hh(a, b, c, d, x[i+ 1], 4 , -1530992060);
            d = __md5hh(d, a, b, c, x[i+ 4], 11,  1272893353);
            c = __md5hh(c, d, a, b, x[i+ 7], 16, -155497632);
            b = __md5hh(b, c, d, a, x[i+10], 23, -1094730640);
            a = __md5hh(a, b, c, d, x[i+13], 4 ,  681279174);
            d = __md5hh(d, a, b, c, x[i+ 0], 11, -358537222);
            c = __md5hh(c, d, a, b, x[i+ 3], 16, -722521979);
            b = __md5hh(b, c, d, a, x[i+ 6], 23,  76029189);
            a = __md5hh(a, b, c, d, x[i+ 9], 4 , -640364487);
            d = __md5hh(d, a, b, c, x[i+12], 11, -421815835);
            c = __md5hh(c, d, a, b, x[i+15], 16,  530742520);
            b = __md5hh(b, c, d, a, x[i+ 2], 23, -995338651);
            a = __md5ii(a, b, c, d, x[i+ 0], 6 , -198630844);
            d = __md5ii(d, a, b, c, x[i+ 7], 10,  1126891415);
            c = __md5ii(c, d, a, b, x[i+14], 15, -1416354905);
            b = __md5ii(b, c, d, a, x[i+ 5], 21, -57434055);
            a = __md5ii(a, b, c, d, x[i+12], 6 ,  1700485571);
            d = __md5ii(d, a, b, c, x[i+ 3], 10, -1894986606);
            c = __md5ii(c, d, a, b, x[i+10], 15, -1051523);
            b = __md5ii(b, c, d, a, x[i+ 1], 21, -2054922799);
            a = __md5ii(a, b, c, d, x[i+ 8], 6 ,  1873313359);
            d = __md5ii(d, a, b, c, x[i+15], 10, -30611744);
            c = __md5ii(c, d, a, b, x[i+ 6], 15, -1560198380);
            b = __md5ii(b, c, d, a, x[i+13], 21,  1309151649);
            a = __md5ii(a, b, c, d, x[i+ 4], 6 , -145523070);
            d = __md5ii(d, a, b, c, x[i+11], 10, -1120210379);
            c = __md5ii(c, d, a, b, x[i+ 2], 15,  718787259);
            b = __md5ii(b, c, d, a, x[i+ 9], 21, -343485551);
            a = __add(a, _oa);
            b = __add(b, _ob);
            c = __add(c, _oc);
            d = __add(d, _od);
        }   return [a, b, c, d];
    }
275516
def parse(self, fo):
        
        #KDIC|6.124756232026243
        #A|517.9999999999999 42.99999999999999 345.99999999999994 25.999999999999996 602.9999999999999 155.99999999999997 2.9999999999999996 91.99999999999999
        #C|5.999999999999999 4.999999999999999 2.9999999999999996 956.9999999999999 91.99999999999999 17.999999999999996 22.999999999999996 275.99999999999994
        #G|340.99999999999994 943.9999999999999 630.9999999999999 6.999999999999999 16.999999999999996 48.99999999999999 960.9999999999999 14.999999999999998
        #T|134.99999999999997 7.999999999999999 19.999999999999996 9.999999999999998 287.99999999999994 776.9999999999999 12.999999999999998 616.9999999999999
        #N|999.9999999999998
        line = fo.readline()
        if not line:
            return []
        
        while not line.startswith("A|"):
            line = fo.readline() 
        matrix = []
        for _ in range(4):
            matrix.append([float(x) for x in line.strip().split("|")[1].split(" ")])
            line = fo.readline()
        #print matrix
        matrix = [[matrix[x][y] for x in range(4)] for y in range(len(matrix[0]))]
        #print matrix
        m = Motif(matrix)
        m.id = "ChIPMunk_w%s" % len(m)
        return [m]
386186
def gelu(x):
  
  cdf = 0.5 * (1.0 + tf.tanh(
      (np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))
  return x * cdf
276402
function () {
            var rand = '' + Math.random() * 1000 * new Date().getTime();
            return rand.replace('.', '').split('').sort(function () {
                return 0.5 - Math.random();
            }).join('');
        }
509872
function calculateCrc32(buf) {
		var CRC_TABLE = [
			0x00000000,
			0x77073096,
			0xee0e612c,
			0x990951ba,
			0x076dc419,
			0x706af48f,
			0xe963a535,
			0x9e6495a3,
			0x0edb8832,
			0x79dcb8a4,
			0xe0d5e91e,
			0x97d2d988,
			0x09b64c2b,
			0x7eb17cbd,
			0xe7b82d07,
			0x90bf1d91,
			0x1db71064,
			0x6ab020f2,
			0xf3b97148,
			0x84be41de,
			0x1adad47d,
			0x6ddde4eb,
			0xf4d4b551,
			0x83d385c7,
			0x136c9856,
			0x646ba8c0,
			0xfd62f97a,
			0x8a65c9ec,
			0x14015c4f,
			0x63066cd9,
			0xfa0f3d63,
			0x8d080df5,
			0x3b6e20c8,
			0x4c69105e,
			0xd56041e4,
			0xa2677172,
			0x3c03e4d1,
			0x4b04d447,
			0xd20d85fd,
			0xa50ab56b,
			0x35b5a8fa,
			0x42b2986c,
			0xdbbbc9d6,
			0xacbcf940,
			0x32d86ce3,
			0x45df5c75,
			0xdcd60dcf,
			0xabd13d59,
			0x26d930ac,
			0x51de003a,
			0xc8d75180,
			0xbfd06116,
			0x21b4f4b5,
			0x56b3c423,
			0xcfba9599,
			0xb8bda50f,
			0x2802b89e,
			0x5f058808,
			0xc60cd9b2,
			0xb10be924,
			0x2f6f7c87,
			0x58684c11,
			0xc1611dab,
			0xb6662d3d,
			0x76dc4190,
			0x01db7106,
			0x98d220bc,
			0xefd5102a,
			0x71b18589,
			0x06b6b51f,
			0x9fbfe4a5,
			0xe8b8d433,
			0x7807c9a2,
			0x0f00f934,
			0x9609a88e,
			0xe10e9818,
			0x7f6a0dbb,
			0x086d3d2d,
			0x91646c97,
			0xe6635c01,
			0x6b6b51f4,
			0x1c6c6162,
			0x856530d8,
			0xf262004e,
			0x6c0695ed,
			0x1b01a57b,
			0x8208f4c1,
			0xf50fc457,
			0x65b0d9c6,
			0x12b7e950,
			0x8bbeb8ea,
			0xfcb9887c,
			0x62dd1ddf,
			0x15da2d49,
			0x8cd37cf3,
			0xfbd44c65,
			0x4db26158,
			0x3ab551ce,
			0xa3bc0074,
			0xd4bb30e2,
			0x4adfa541,
			0x3dd895d7,
			0xa4d1c46d,
			0xd3d6f4fb,
			0x4369e96a,
			0x346ed9fc,
			0xad678846,
			0xda60b8d0,
			0x44042d73,
			0x33031de5,
			0xaa0a4c5f,
			0xdd0d7cc9,
			0x5005713c,
			0x270241aa,
			0xbe0b1010,
			0xc90c2086,
			0x5768b525,
			0x206f85b3,
			0xb966d409,
			0xce61e49f,
			0x5edef90e,
			0x29d9c998,
			0xb0d09822,
			0xc7d7a8b4,
			0x59b33d17,
			0x2eb40d81,
			0xb7bd5c3b,
			0xc0ba6cad,
			0xedb88320,
			0x9abfb3b6,
			0x03b6e20c,
			0x74b1d29a,
			0xead54739,
			0x9dd277af,
			0x04db2615,
			0x73dc1683,
			0xe3630b12,
			0x94643b84,
			0x0d6d6a3e,
			0x7a6a5aa8,
			0xe40ecf0b,
			0x9309ff9d,
			0x0a00ae27,
			0x7d079eb1,
			0xf00f9344,
			0x8708a3d2,
			0x1e01f268,
			0x6906c2fe,
			0xf762575d,
			0x806567cb,
			0x196c3671,
			0x6e6b06e7,
			0xfed41b76,
			0x89d32be0,
			0x10da7a5a,
			0x67dd4acc,
			0xf9b9df6f,
			0x8ebeeff9,
			0x17b7be43,
			0x60b08ed5,
			0xd6d6a3e8,
			0xa1d1937e,
			0x38d8c2c4,
			0x4fdff252,
			0xd1bb67f1,
			0xa6bc5767,
			0x3fb506dd,
			0x48b2364b,
			0xd80d2bda,
			0xaf0a1b4c,
			0x36034af6,
			0x41047a60,
			0xdf60efc3,
			0xa867df55,
			0x316e8eef,
			0x4669be79,
			0xcb61b38c,
			0xbc66831a,
			0x256fd2a0,
			0x5268e236,
			0xcc0c7795,
			0xbb0b4703,
			0x220216b9,
			0x5505262f,
			0xc5ba3bbe,
			0xb2bd0b28,
			0x2bb45a92,
			0x5cb36a04,
			0xc2d7ffa7,
			0xb5d0cf31,
			0x2cd99e8b,
			0x5bdeae1d,
			0x9b64c2b0,
			0xec63f226,
			0x756aa39c,
			0x026d930a,
			0x9c0906a9,
			0xeb0e363f,
			0x72076785,
			0x05005713,
			0x95bf4a82,
			0xe2b87a14,
			0x7bb12bae,
			0x0cb61b38,
			0x92d28e9b,
			0xe5d5be0d,
			0x7cdcefb7,
			0x0bdbdf21,
			0x86d3d2d4,
			0xf1d4e242,
			0x68ddb3f8,
			0x1fda836e,
			0x81be16cd,
			0xf6b9265b,
			0x6fb077e1,
			0x18b74777,
			0x88085ae6,
			0xff0f6a70,
			0x66063bca,
			0x11010b5c,
			0x8f659eff,
			0xf862ae69,
			0x616bffd3,
			0x166ccf45,
			0xa00ae278,
			0xd70dd2ee,
			0x4e048354,
			0x3903b3c2,
			0xa7672661,
			0xd06016f7,
			0x4969474d,
			0x3e6e77db,
			0xaed16a4a,
			0xd9d65adc,
			0x40df0b66,
			0x37d83bf0,
			0xa9bcae53,
			0xdebb9ec5,
			0x47b2cf7f,
			0x30b5ffe9,
			0xbdbdf21c,
			0xcabac28a,
			0x53b39330,
			0x24b4a3a6,
			0xbad03605,
			0xcdd70693,
			0x54de5729,
			0x23d967bf,
			0xb3667a2e,
			0xc4614ab8,
			0x5d681b02,
			0x2a6f2b94,
			0xb40bbe37,
			0xc30c8ea1,
			0x5a05df1b,
			0x2d02ef8d,
		];

		var crc = ~0;
		for (var ix = 0; ix < buf.length; ix++) {
			var offset = (crc ^ buf[ix]) & 0xff;
			crc = (crc >>> 8) ^ CRC_TABLE[offset];
		}

		return crc ^ -1;
	}
1216767
public float rSum(float[] y, float[] w) {
    float tmp1 = (float) 0.0, tmp2 = (float) 0.0;
    for (int i = 0; i < y.length; i++) {
      tmp1 += y[i] * w[i];
      tmp2 += w[i];
    }

    return correctTo01(tmp1 / tmp2);
  }
908397
function randProbPrime(k) {
  if (k>=600) return randProbPrimeRounds(k, 2); //numbers from HAC table 4.3
  if (k>=550) return randProbPrimeRounds(k, 4);
  if (k>=500) return randProbPrimeRounds(k, 5);
  if (k>=400) return randProbPrimeRounds(k, 6);
  if (k>=350) return randProbPrimeRounds(k, 7);
  if (k>=300) return randProbPrimeRounds(k, 9);
  if (k>=250) return randProbPrimeRounds(k, 12); //numbers from HAC table 4.4
  if (k>=200) return randProbPrimeRounds(k, 15);
  if (k>=150) return randProbPrimeRounds(k, 18);
  if (k>=100) return randProbPrimeRounds(k, 27);
              return randProbPrimeRounds(k, 40); //number from HAC remark 4.26 (only an estimate)
}
101015
function( num ) {
		var n = new Buffer(8);
		if (SAFE) { if (num == 0.0) { }
		else if (Math.abs(num) < 1.7E-108) 
			throw new Errors.PackError('Packing float bigger than 64-bits ('+num+')!');
		else if (Math.abs(num) > 1.7E+108) 
			throw new Errors.PackError('Packing float bigger than 64-bits ('+num+')!');
		}
		packViewF64[0] = num;
		for (var i=0; i<8; ++i) n[i]=packViewU8[i];
		return n;
	}
485897
function randnBM() {
  const u = 1 - Math.random() // Subtraction to flip [0, 1) to (0, 1].
  const v = 1 - Math.random()
  return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v)
}
570221
static BigDecimal calculateFuzzAmount(ParamPrefixEnum cmpValue, BigDecimal theValue) {
		if (cmpValue == ParamPrefixEnum.APPROXIMATE) {
			return theValue.multiply(new BigDecimal(0.1));
		} else {
			String plainString = theValue.toPlainString();
			int dotIdx = plainString.indexOf('.');
			if (dotIdx == -1) {
				return new BigDecimal(0.5);
			}

			int precision = plainString.length() - (dotIdx);
			double mul = Math.pow(10, -precision);
			double val = mul * 5.0d;
			return new BigDecimal(val);
		}
	}
180336
function(s) {
    s = s.replace(/\s/, "");
    var v = window.parseFloat(s);

    return s.match(/[^m]s$/i)
      ? v * 1000
      : v;
  }
1351315
function pnorm(qn) {
        var b = [1.570796288, 0.03706987906, -0.8364353589e-3,
                -0.2250947176e-3, 0.6841218299e-5, 0.5824238515e-5,
                -0.104527497e-5, 0.8360937017e-7, -0.3231081277e-8,
                0.3657763036e-10, 0.6936233982e-12],
            w1 = qn,
            w3 = -Math.log(4.0 * w1 * (1.0 - w1)),
            i = 1;

        if (qn < 0.0 || qn > 1.0) { return 0.0; }
        if (qn === 0.5) { return 0.0; }
        if (qn > 0.5) { w1 = 1.0 - w1; }

        w1 = b[0];
        for (i; i < 11; i++) {
            w1 += b[i] * Math.pow(w3, i);
        }

        if (qn > 0.5) { return Math.sqrt(w1 * w3); }

        return -Math.sqrt(w1 * w3);
    }
835361
function (number, decimals, decPoint, thousandsSep) {

            number = ("" + number).replace(/[^0-9+\-Ee.]/g, "");

            var num        = !isFinite(+number) ? 0 : +number,
                prec       = !isFinite(+decimals) ? 0 : Math.abs(decimals),
                separator  = thousandsSep === undefined ? "," : thousandsSep,
                decimal    = decPoint === undefined ? "." : decPoint,
                toFixedFix = function (n, prec) {
                    var k = Math.pow(10, prec);
                    return "" + (Math.round(n * k) / k).toFixed(prec);
                },

                // Fix for IE parseFloat(0.55).toFixed(0) = 0;
                result     = (prec ? toFixedFix(num, prec) : "" + Math.round(num)).split(".");

            if (result[0].length > 3) {
                result[0] = result[0].replace(/\B(?=(?:\d{3})+(?!\d))/g, separator);
            }

            return result.join(decimal);
        }