Published
Edited
Mar 19, 2019
Importers
function* A000002(n=1) {
let x = -1
let y = x
// TODO fast forward to index position n...
const out = [2, 1]
do {
yield out[x&1]
const f = y &~ (y+1)
x ^= f
y = (y+1) | (f & (x>>1))
} while (++n < Number.MAX_SAFE_INTEGER)
}
assert(A000002_expected, take(A000002_expected.length, A000002()))
function* A000004(n=0) {
do {
yield 0
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000004_expected, take(A000004_expected.length, A000004()))
function* A000005(n=1) {
// TODO quite a bit of room to optimize
do {
if (n==1) {
yield 1
continue
}
const pp = primePowers(n)
let v = 1
for (let [p, e] of pp) {
v *= (e + 1)
}
yield v
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000005_expected, take(A000005_expected.length, A000005()))
function* A000006(n=1) {
// TODO seek to index position n
for (let p of primes()) {
yield Math.floor(Math.sqrt(p))
}
}
assert(A000006_expected, take(A000006_expected.length, A000006()))
function* A000007(n=0) {
do {
yield (n ? 0 : 1)
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000007_expected, take(A000007_expected.length, A000007()))
function* A000010(n=1) {
do {
if (n==1) {
yield 1
continue
}
let v = n
// loop over distinct factors
for (let p of new Set([...factors(n)])) {
v *= p-1
v /= p
}
yield v
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000010_expected, take(A000010_expected.length, A000010()))
function* A000012(n=0) {
// TODO why does OEIS have these indices running backward?
do {
yield 1
} while (++n <= Number.MAX_SAFE_INTEGER)
}
function* A000027(n=1) {
do {
yield n
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000027_expected, take(A000027_expected.length, A000027()))
function* A000037(n=1) {
// while (n <= Number.MAX_SAFE_INTEGER) ?
do {
yield n + Math.floor(1/2 + Math.sqrt(n))
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000037_expected, take(A000037_expected.length, A000037()))
assert(take(1,A000037(1234))[0], 1269) // value at 1,234th index position of sequence
assert(A000037(1234).next().value, 1269)
A000040 = primes // TODO take an n
assert(A000040_expected, [...itertools.takewhile(A000040(), (p) => p <= 271)])
function* A000042(n=1, b='') {
// obviously this falls down fast without bigints...
// could force strings here instead, though prob want a custom numeric type anyway
// opting into custom type accomplished with second "base" arg
do {
if (typeof b === 'string') {
yield Array.from({ length: n }).fill('1').join('')
} else if (typeof b === 'number') {
// base "b" repdigit
// TODO BigInt polyfill?
yield (b**n - 1) / (b - 1)
}
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000042_expected, take(A000042_expected.length, A000042()))
assert(A000042(5,10).next().value, 11111)
assert(A000042(5,2).next().value, parseInt('11111',2))
function* A000217(n=0) {
// TODO support characters over an alphabet?
do {
yield choose(n+1,2)
} while (++n <= Number.MAX_SAFE_INTEGER)
}
function* A000290(n=0) {
// TODO support characters over an alphabet?
do {
yield n*n
} while (++n <= Number.MAX_SAFE_INTEGER)
}
assert(A000290_expected, take(A000290_expected.length, A000290()))
function* A006881(n=1) {
// seek to first value... TODO should we `yield null` for each place?
if (n < 6) n = 6
do {
// TODO base generator to emit pairs of factors, can be composed back together
if (n % 2 == 0) {
// for singly even n, divide out by 2 and run a prime test
if (n % 4 == 2 && isPrime(n/2)) yield n
} else {
// seek out first prime factor, test for primality of residue
// TODO we can be smarter than this by doubly iterating primes
const f1 = factors(n).next().value
const f2 = n / f1
if (f1 != f2 && isPrime(f2)) yield n
}
} while (++n <= Number.MAX_SAFE_INTEGER)
}
take = (n, iterable) => [...itertools.itake(n, itertools.icompact(iterable))]
function* factors(n) {
let x = Math.max(1, Math.floor(n)) || 1
let i = 0
let q
for (const p of primes()) {
if (!(p * p <= x)) break;
while ((q = x / p) > 1 && q === Math.floor(q)) {
x = q
yield p
}
if (++i % 1000 === 0) {
yield
}
}
yield x
}
primePowers = (n) => countValues(itertools.groupby([...itertools.icompact(factors(n))]))
countValues = (grouped) => [...itertools.imap(grouped, ([k, v]) => [k, [...v].length])]
One platform to build and deploy the best data apps
Experiment and prototype by building visualizations in live JavaScript notebooks. Collaborate with your team and decide which concepts to build out.
Use Observable Framework to build data apps locally. Use data loaders to build in any language or library, including Python, SQL, and R.
Seamlessly deploy to Observable. Test before you ship, use automatic deploy-on-commit, and ensure your projects are always up-to-date.