0joshuaolson1 / factoradic Goto Github PK

Since wasm has overhead, recommend jsbn until I feel like finding an Emscripten alternative for WebAssembly (like https://github.com/alpertron/calculators).

Note: Chrome 67 has BigInt; Firefox doesn't yet.

Most CDNs don't need submitting...

Alternative to #26

Pascal's triangle?

The WebAssembly<->js interface might have too much overhead, but even ignoring asm.js support, simple optimizations like <uint variable> |= 0 give modern JS engines hints.

A more efficient atop(ptoa(p), wantPermuted) would be

function(p, wantPermuted){return p.map(function(i){return wantPermuted[i];});}

This makes a new array instead of permuting wantPermuted, but if Factoradic used an indexof reverse index here and a user wanted (to pass in) a wantPermuted copy anyway, that'd be two new arrays...

...I'll just write the indexof approach here sometime.

to the readme, or a separate file? Which are relevant enough to Factoradic?

• comparison of randomness sources
  • by API or browser, no credentials required:
    • https://www.random.org/
    • https://qrng.anu.edu.au/
  • integrated with/provided by hardware (TRNGs?)
  • OSs, PRNGs, hashes/checksums, and why not
  • external hardware? (TRNGs)
  • the issue of trust
• derangement
• bigint library/website recommendation (#19 <- not very good; I may need to supplement its poor docs) (see usage example linked in last bullet)
• products of factorials
• utilities in issue 25

Note that jsdelivr tries to use a bad minifier for you. I don't know if creating a index.min.js would change that. (EDIT: jsDelivr upgraded UglifyJS and may be nice now; index.min.js is still a good idea)

Should test.js be the one to test the minified version as well?

wzrd.in started trying to minify from 1.1.0 onward. Naturally it doesn't know about alternative loop strategies and stuff that shortens the code further. (EDIT: They don't respond to open issues well.)

• readme improvements
• the other issues

...in another repo, though.

console/terminal/command-line file shuffler/renamer - see:

-https://ziglang.org
-https://github.com/shenwei356/brename
-https://github.com/alexandres/terashuf

As noted in the changelog after having already released...

Create an alternative ntop (and associated entropy estimator) that can easily pull from arrays (not like a) of 2^x, [21*23*25 /*< 2**53*/], etc.

Note to self: see if any (odd-number double) factorial identities in https://arxiv.org/abs/0906.1317 could help; or see:

• http://www.luschny.de/math/factorial/FastFactorialFunctions.htm (swinging factorials...)
• https://en.wikipedia.org/wiki/Computational_complexity_of_mathematical_operations#Number_theory

Other identities?

• https://github.com/soniakeys/integer
• http://oeis.org/A034876 | A034876 - OEIS
• http://oeis.org/A034878 | A034878 - OEIS
• http://oeis.org/A000040 | A000040 - OEIS
• http://oeis.org/A075082 | A075082 - OEIS
• http://oeis.org/A001013 | A001013 - OEIS
• http://mathworld.wolfram.com/FactorialProducts.html | Factorial Products -- from Wolfram MathWorld
• http://www.chegg.com/homework-help/shuffling-linked-list-develop-implement-divide-conquer-algor-chapter-2.2-problem-18e-solution-9780132762557-exc | Solved: Shuffling a linked list. Develop and implement a divide... | Chegg.com
• http://www.chegg.com/homework-help/questions-and-answers/shuffling-linked-list-design-divide-conquer-algorithm-randomly-shuffles-linked-list-o-nlog-q17997312 | Shuffling A Linked List. Design A Divide And Conqu... | Chegg.com
• https://www.geeksforgeeks.org/shuffle-a-given-array/ | Shuffle a given array - GeeksforGeeks
• https://www.geeksforgeeks.org/shuffle-2n-integers-format-a1-b1-a2-b2-a3-b3-bn-without-using-extra-space/ | Shuffle 2n integers in format {a1, b1, a2, b2, a3, b3, ......, an, bn} without using extra space - GeeksforGeeks
• https://stackoverflow.com/questions/12167630/algorithm-for-shuffling-a-linked-list-in-n-log-n-time | Algorithm for Shuffling a Linked List in n log n time - Stack Overflow

Functional is not first class - thanks, unoptimized call stack implementation detail leakage. Instead:

function P(l){var a = Array(l); loop(0, l-1, function(l){a[l] = l;}); return a;}

, or equally

function P(l){for(var a = Array(l); a[--l] = l;); return a;}

Side effect: shortens the test function.

Also note that you're free to get n from anywhere, so it's not unsupported...

Since they're mutually exclusive, this might have a net benefit of removing the documented falsy complication, enforcing the exclusivity, and side-stepping the question of what happens when both are given.

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Typed_arrays

Supported in environments stuck at ES5?

var buffer = new ArrayBuffer(2(bytes) * desiredLength);
var array = new Uint16Array(buffer);

Should this affect the api, since an 'array' has both a buffer and a view?

It's better supported (maybe irrelevant, but a reason for a tie-breaker)

A nonobvious advantage would be removing the ES6 requirement.

And what about Flow? Or Closure Compiler or JSDoc styles?

To be closed on 2.0.5 release.

Literally the only advantage here of ES6 is brevity.

Literally the only advantages of ES5 are use in bad browsers and readability for those unfamiliar or uncomfortable with ES2015.

It's possible that using this from the browser (script tag, cdn, etc.) makes top-level identifier pollution.

E.g. atop([1,2]) can be split as atop([0,2], atop([1,0])), but which is not commutative with atop([1,0], atop([0,2])).

(and why this is convenient)

Expecially now that I ninja'd in a note: https://github.com/0joshuaolson1/factoradic/blob/master/README.md#number-representations-are-not-unique

...and what other conditions should be investigated/documented/improved? (e.g. #23; if in atop, a's length doesn't correspond to p's)

We can return here now that loop is gone:

E.g.:

atop(array[, permutable])

Converts/transform array into a permutation of [0, 1...]
(unless permutable is provided, in which case...