I am a very very creative app but it seems to have work hard and it doesn't even open. (written using predictive text)
{
let height = 2000;
let marginBottom = 30;
let marginTop = 30;
const yAxis = Plot.plot({
width: 40,
height,
marginTop,
marginBottom
});
const chart = Plot.plot({
style: {
backgroundColor: "#222"
},
axis: null,
height,
width: 1000,
margin: 20,
marginLeft: 40,
marginRight: 120,
r: {
type: "log",
range: [2, 10],
transform: (d) => _.max(intLogs?.[d]?.factors)
},
color: {
type: "ordinal",
scheme: "Reds",
transform: (d) => intLogs?.[d]?.factors?.length
},
marks: [
Plot.tree(intLogPaths, {
path: "path",
r: "node:name",
fill: "node:name",
// fill: "white",
title: "node:name",
textStroke: "black"
})
]
});
chart.classList.add("chart");
const scrollbar = html`<div class="scrollbar">`;
scrollbar.append(chart);
const div = html`<div class="container">`;
div.append(yAxis, scrollbar);
return div;
}
intLogPaths = {
let drawLimit = 256;
let reverseMap = groupValues(
intLogs.slice(0, drawLimit).map((n) => n.intLog)
);
let paths = [];
let addPaths = (num, prefix = "") => {
if (!reverseMap[num]) {
paths.push({
path: prefix + num,
name: num
});
} else {
for (let child of reverseMap[num]) {
if (+child !== +num) {
addPaths(child, "" + prefix + num + "/");
}
}
}
};
for (let i of getPrimes(drawLimit)) {
addPaths(i);
}
return paths;
}
diff = {
let myLimit = 2 ** 10;
let twos = (n) =>
_.sum(_.range(1, Math.log2(n) + 1).map((a) => 2 * Math.floor(n / 2 ** a)));
let primes = getPrimes(myLimit);
let odds = (n) => primes.filter((p) => p > n / 2 && p <= n).length * (n / 2);
return _.range(1, myLimit).map((n) => ({
index: n,
odds: odds(n),
twos: 2 * n,
diff: odds(n) - twos(n)
}));
}
data = intLogs
Plot.plot({
marks: [
Plot.line(ilogSum.slice(5000), {
x: "index",
y: "ratio",
stroke: "blue",
tip: true
})
// Plot.line(ilogSum, { x: "index", y: "asymptote", stroke: "red" })
]
})
{
let count = 10000;
return (
_.sum(ilogSum.map((data) => data.ratio).slice(ilogSum.length - count)) /
count
);
}
ilogSum = {
// Show that the Wallis product of pi has an ilog of -infinity
let partialSums = [];
let graphLimit = 2 ** 18;
let intLogs = getIntLogs(graphLimit);
let altSum = 0;
let sum = 0;
let primeSum = 0;
let primes = getPrimes(graphLimit);
let primeIndex = 0;
for (let [index, ilog] of Object.entries(intLogs)) {
while (primes[primeIndex] <= index) {
let p = primes[primeIndex];
primeSum += p / (p - 1);
primeIndex++;
}
altSum += ilog.intLog * (index % 2 === 0 ? 1 : -1);
sum += ilog.intLog;
partialSums.push({
index: +index,
sum,
altSum,
asymptote: index * primeSum * 0.83,
ratio: (index * primeSum) / sum
});
}
return partialSums;
}
allPrimeFactors = primeFactors(limit)
{
// When soprf(n) has more factors than n
let reversals = [];
for (let n of _.range(1, limit)) {
let intLog = intLogs[n].intLog;
if (allPrimeFactors[intLog].length > allPrimeFactors[n].length) {
reversals.push(n);
}
}
return reversals;
}
maxFactorReversals.map((n) => {
let maxFactor = _.max(allPrimeFactors[n]);
let soprfMaxFactor = _.max(allPrimeFactors[intLogs[n].intLog]);
return {
num: n,
maxFactor,
soprfMaxFactor,
diff: soprfMaxFactor - maxFactor
};
})
maxFactorReversals = {
let reversals = [];
for (let n of _.range(1, limit)) {
let intLog = intLogs[n].intLog;
// Ignore primes
if (intLogs[intLog].intLog === intLog) {
continue;
}
// Ignore perfect powers
if (isPerfectPower(n)) {
continue;
}
if (_.max(allPrimeFactors[intLog]) > _.max(allPrimeFactors[n])) {
reversals.push(n);
}
}
return reversals;
}
soprfRecordBreakers = {
let max = 0;
let recordBreakers = [];
for (let i of _.range(0, limit)) {
if (intLogs[i].intLog !== i && intLogs[i].intLog > max) {
max = intLogs[i].intLog;
recordBreakers.push(i);
}
}
return recordBreakers;
}
// Int log sequence record breakers
recordBreakers = {
let limit = 2 ** 20;
let pathLengths = [];
let intLogs = getIntLogs(limit);
let maxPathLength = 1;
let pathRecords = [];
for (let n of _.range(0, limit)) {
if (intLogs[n].intLog === n) {
pathLengths[n] = 1;
} else {
pathLengths[n] = pathLengths[intLogs[n].intLog] + 1;
}
if (pathLengths[n] > maxPathLength) {
pathRecords.push(n);
maxPathLength = pathLengths[n];
}
}
return pathRecords;
}
intLogs
X*
—
Y*
—
Color
—
Size
—
Facet X
—
Facet Y
—
Mark
Auto
Type Chart, then Shift-Enter. Ctrl-space for more options.
limit = 2 ** 16
intLogs = getIntLogs(limit)
function groupValues(map) {
let result = {};
for (let [key, value] of Object.entries(map)) {
if (!result[value]) {
result[value] = [];
}
result[value].push(key);
}
return result;
}
function getIntLogs(n) {
let factors = primeFactors(n);
// return factors;
return factors.map((fs, i) => ({ factors: fs, intLog: fs ? _.sum(fs) : i }));
}
function isPerfectPower(n) {
let factorExponents = Object.values(_.countBy(allPrimeFactors[n]));
return factorExponents.reduce((a, b) => gcd(a, b)) > 1;
}
function gcd(a, b) {
let t = b;
while (b !== 0) {
t = b;
b = a % b;
a = t;
}
return a;
}
import { primeFactors, getPrimes } from "@tesseralis/math"
Purpose-built for displays of data
Observable is your go-to platform for exploring data and creating expressive data visualizations. Use reactive JavaScript notebooks for prototyping and a collaborative canvas for visual data exploration and dashboard creation.
