parser = {
const parser = math.parser();
parser.set("a", A);
return parser;
}
// experiments are an array of objects with a name and a function to run.
experiments = [
{ name: "map cube", run: () => math.map(A, math.cube) },
{ name: "math dotPow", run: () => math.dotPow(A, 3) },
{ name: "parser cube", run: () => parser.evaluate("a.^3") },
{ name: "map cube callback", run: () => math.map(A, (x) => math.cube(x)) },
{
name: "map Math cube callback",
run: () => math.map(A, (x) => Math.pow(x, 3))
},
{
name: "flat map",
run: () => flatMap(A, (x) => math.cube(x))
},
{ name: "map recurse", run: () => recurseMap((x) => Math.pow(x, 3), A) },
{
name: "map recurse forEach",
run: () => recurseForEach((x) => Math.pow(x, 3), A)
},
{ name: "typed map", run: () => typedMap(math.cube, A) },
{ name: "typed map trick", run: () => typedMap1(math.cube, A) },
{
name: "map signature implementation",
run: () => math.map(A, math.typed.resolve(math.cube, [0.1]).implementation)
}
]
function flatMap(A, callback) {
const sizeA = math.size(A);
const flatA = math.flatten(A);
return math.reshape(
flatA.map((x) => Math.pow(x, 3)),
sizeA
);
}
math.deepEqual(typedMap(math.cube, A), math.map(A,math.cube))
math.typed.resolve(math.cube, [1])
function recurseMap(callback, ...args) {
return _recurse(args[0]);
function _recurse(value) {
if (Array.isArray(value)) return value.map((v) => _recurse(v));
return callback(value);
}
}
function recurseForEach(callback, ...args) {
return _recurse(args[0]);
function _recurse(value) {
if (Array.isArray(value)) return value.forEach((v) => _recurse(v));
return callback(value);
}
}
function typedMap(callback, ...args) {
let implementation = () => {
throw new Error("null implemntation");
};
if (args.length === 1) return _recurse(args[0]);
function _recurse(value) {
if (Array.isArray(value)) {
return value.map((v) => _recurse(v));
}
try {
return implementation(value);
} catch {
implementation = math.typed.resolve(callback, [value]).implementation;
return implementation(value);
}
}
}
function typedMap1(callback, ...args) {
let implementation = math.typed.resolve(callback, [0.1]).implementation;
if (args.length === 1) return _recurse(args[0]);
function _recurse(value) {
if (Array.isArray(value)) {
return value.map((v) => _recurse(v));
}
return implementation(value);
}
}
function typedMap1ForEach(callback, ...args) {
let implementation = math.typed.resolve(callback, [0.1]).implementation;
if (args.length === 1) return _recurse(args[0]);
function _recurse(value) {
if (Array.isArray(value)) {
value.forEach((v) => _recurse(v));
}
return implementation(value);
}
}
function typedMapForEach(callback, ...args) {
let implementation = () => {
throw new Error("null implemntation");
};
if (args.length === 1) return _recurse(args[0]);
function _recurse(value) {
if (Array.isArray(value)) {
value.forEach((v) => _recurse(v));
}
try {
return implementation(value);
} catch {
implementation = math.typed.resolve(callback, [value]).implementation;
return implementation(value);
}
}
}
math = import("https://cdn.jsdelivr.net/npm/mathjs@latest/+esm")
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.
