plotlyGraph = {
const { vsArray } = mutipleSimulation;
const layout = {
title: "Dim: " + k,
scene: { camera: { eye: { x: 1.87, y: 0.88, z: -0.64 } } },
autosize: false,
width: 600,
height: 600,
margin: {
l: 65,
r: 50,
b: 65,
t: 90
}
};
const cs = d3.scaleLinear().domain([-1, 1]).range([0, 255]);
const trace1 = {
x: vsArray.map((d) => d.v1),
y: vsArray.map((d) => d.v2),
z: vsArray.map((d) => d.v3),
type: "scatter3d",
mode: "markers",
// opacity: 0.5,
marker: {
size: 1.5,
color: vsArray.map((d) => d3.rgb(cs(d.v1), cs(d.v2), cs(d.v3)).hex())
}
};
const div = htl.html`<div></div>`;
const fig = await Plotly.newPlot(div, [trace1], layout);
console.log(fig);
return fig;
}
{
const { eigenvalueArray } = mutipleSimulation;
const ratios = [];
let array;
for (let j = 0; j < n; ++j) {
array = eigenvalueArray.filter((d) => d.j === j);
ratios.push({
j,
v: array.filter((d) => d.v < -0.0001).length / array.length
});
}
return ratios;
}
mutipleSimulation = {
const eigenvalueArray = [],
vsArray = [];
let data, v1, v2, v3;
for (let i = 0; i < repeat; ++i) {
data = mkExampleData();
v1 = data.mat.data[0][1];
v2 = data.mat.data[1][2];
v3 = data.mat.data[0][2];
vsArray.push({ v1, v2, v3, i });
data.S.map((v, j) => eigenvalueArray.push({ v: v > 1 ? 1 : v, i, j }));
}
return { eigenvalueArray, vsArray };
}
exampleData = mkExampleData()
/**
* Make one data for example
*/
mkExampleData = () => {
const mat = mkCovMat(),
array = mat2array(mat),
svd = new ML.SVD(mat),
S = reSignEigenvalues(svd);
return { mat, array, svd, S };
}
/**
* Re-sign the eigenvalues
*/
reSignEigenvalues = (svd) => {
const { s, U, V } = svd,
S = [];
for (let i = 0; i < n; ++i) {
S[i] = (s[i] * U.data[0][i]) / V.data[0][i];
}
return S;
}
/**
* Convert mat into array, it is an array of {v, i, j}
*/
mat2array = (mat) => {
let array = [];
mat.data.map((vec, i) => vec.map((v, j) => array.push({ v, i, j })));
return array;
}
/**
* Make random matrix for simulation of covariance matrix
*/
mkCovMat = () => {
let mat, v;
if (k > 0) {
let mat1 = normalizeRows(ML.Matrix.random(n, k).sub(0.5));
mat = mat1.mmul(mat1.transpose());
} else {
mat = ML.Matrix.zeros(n, n);
for (let i = 0; i < n; ++i) {
for (let j = i; j < n; ++j) {
v = i === j && fixDiag ? 1.0 : Math.random() - 0.5;
mat.data[i][j] = v;
mat.data[j][i] = v;
}
}
}
return mat;
}
normalizeRows = (mat) => {
const { rows } = mat;
let s,
diag = mat.mmul(mat.transpose()).diag();
for (let j = 0; j < rows; ++j) {
s = Math.sqrt(diag[j]);
mat.data[j] = mat.data[j].map((d) => d / s);
}
return mat;
}
mat2.mmul(mat2.transpose())
mat2 = normalizeRows(mat1)
mat1 = ML.Matrix.random(n, k)
ML = require("https://cdn.jsdelivr.net/npm/ml-matrix@6.10.5/matrix.umd.min.js")
d3 = require("d3")
Plotly = require("https://cdn.plot.ly/plotly-2.20.0.min.js")
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.
