2b:null 2c:["$","title",null,{"children":"Linear Algebra | Kjerand Pedersen | Observable"}] 31:T141d,Vector = { const accessors = ({ x: 0, r: 0, i: 0, s: 0, y: 1, g: 1, j: 1, t: 1, z: 2, b: 2, k: 2, u: 2, w: 3, a: 3, l: 3, v: 3, }); class Vector extends Array { /** * Instantiate a vector from an array. * @param {number[]} arr array of numbers * @return {Vector} */ static fromArray(arr) { return new Vector(...arr); } /** * Add one or more vectors to this vector * @param {...number[]} vectors vectors to add to this * @return {Vector} */ add(...vectors) { if (vectors.length === 1) { return add(this, vectors[0]); } return addAll(vectors, this); } /** * Add a scaled version of a vector to this vector * @param {number[]} vector vectors to add to this * @param {number} factor scaling factor * @return {Vector} */ addScaled(vector, factor) { return addScaled(this, vector, factor, this); } /** * Subtract one or more vectors from this vector * @param {...number[]} vectors vectors to subtract from this vector * @return {Vector} */ sub(...vectors) { if (vectors.length === 1) { return sub(this, vectors[0]); } return subAll(this, vectors); } /** * Subtract a scaled version of a vector from this vector * @param {number[]} vector vector to subtract from this * @param {number} factor scaling factor * @return {Vector} */ subScaled(vector, factor) { return subScaled(this, vector, factor, this); } /** * Calculate the scalar product (length) of this vector. * @return {number} */ scalar() { return scalar(this); } /** * Scale this vector by a factor * @param {number} factor scaling factor * @param {Array/Vector} target optional array/vector to avoid mutating this vector * @return {Vector} */ scale(factor, target = null) { return scale(this, factor, target || this); } /** * Negate all components of this vector * @param {Array/Vector} target optional array/vector to avoid mutating this vector * @return {Vector} */ negate(target = null) { return this.scale(-1, target); } /** * Normalize this vector * @param {Array/Vector} target optional array/vector to avoid mutating this vector * @return {Vector} */ normalize(target = null) { return norm(this, target || this); } /** * Calculate the dot product between this vector and the passed in argument * @param {number[]} other vector * @return {number} dot product */ dot(other) { return dot(this, other); } /** * Find the cross product vector between this vector and the passed in argument. * Only for 3d vectors! * @param {number[]} other 3d vector * @param {Array/Vector} target optional array/vector to avoid mutating this vector * @return {Vector} */ cross(other, target = null) { return cross(this, other, target); } /** * Calculate the psudo cross product between this vector and the passed in argument. * Only for 2d vectors! * @param {number[]} other 2d vector * @return {number} psudo cross product */ cross2(other) { return cross2(this, other); } /** * Calculate the distance between this coordinates to the coordinates supplied in the argument * @param {number[]} other coordinates * @return {number} distance */ distance(other) { return dist(this, other); } /** * Clone/copy vector * @return {Vector} */ clone() { return new Vector(...this); } /** * Mimic the swizzle feature in glsl. Supply the swizzle pattern as a string, using the * defined accessors (xyzw, rgba, ijkl or stuv): * ex: vec.swizzle('xxyw') or vec.swizzle('rrra) * @param {string} pattern swizzle pattern * @param {Array/Vector} target optional array/vector to avoid mutating this vector * @return {Vector} */ swizzle(pattern, target = null) { let values = this; if (!target) { target = this; values = [...this]; } const l = target.length || pattern.length; for (let i = 0; i < l; i++) { const ai = accessors[pattern[i]]; target[i] = values[ai]; } return target; } /** * Test if this vector is a null vector * @param {number} epsilon epsilon */ isNull(epsilon = 0) { return isNullVec(this, epsilon); } /** * Assign values to this vector * @param {...number} v values to set * @return {Vector} */ set(...v) { for (let i = 0; i < v.length; i++) { /** assign value */ this[i] = v[i]; } return this; } } // add getters and setters from accessors Object.keys(accessors).forEach((a) => { Object.defineProperty(Vector.prototype, a, { get() { return this[accessors[a]]; }, set(v) { if (Number.isFinite(v)) { this[accessors[a]] = v; } }, }); }); return Vector; }32:T4d01,Matrix = { function rowsToColumns(arr, cols, target = null) { cols = cols || 1; const rows = cols === 1 ? arr.length : ~~(arr.length / cols); if (target) { if (target === arr) { arr = [...arr]; // copy } } else { target = new Array(rows * cols); } let n = 0; for (let i = 0; i < rows; i++) { for (let j = 0; j < cols; j++) { target[rows * j + i] = arr[n++]; } } return target; } class Matrix extends Array { /** * Creates an identity matrix with rows and columns equal to size. * @param {number} size dimension * @return {Matrix} */ static identity(size = 4) { const m = new Matrix(size).fill(0); for (let i = 0; i < m.length; i += size + 1) { m[i] = 1; } return m; } /** * Traverse an array as a matrix, either rows-first or columns first. * @param {number[]} arr array to traverse as a matrix * @param {number} cols number of columns to split the array into * @param {function} callback function to be executed for each element * @param {boolean} rowsFirst traverse order */ static traverse(arr, cols = 1, callback = () => ({}), rowsFirst = true) { const rows = arr.rows || ~~(arr.length / cols); if (rowsFirst) { let n = 0; for (let c = 0; c < cols; c++) { for (let r = 0; r < rows; r++) { const idx = c * rows + r; callback(arr[idx], n++, r, c, idx); } } } else { arr.forEach((v, i) => callback(v, i, i % cols, ~~(i / rows), i)); } } /** * Instantiate a matrix from an array. * @param {number[]} arr array of numbers * @param {number} columns number of columns to split the array into * @param {boolean} rowsFirst traverse order * @param {boolean} mutateArgs set if the input array should be mutated or not * @return {Matrix} */ static fromArray(arr, columns = 1, rowsFirst = true, mutateArgs = false) { const rows = columns === 1 ? arr.length : ~~(arr.length / columns); return new Matrix(rows, columns, arr, rowsFirst, mutateArgs); } /** * Create a matrix from vectors. Each vector will be a column in the matrix * and the number of rows are determined by the vector dimension. * @param {...number[]} vectors * @return {Matrix} */ static fromVectors(...vectors) { const cols = vectors.length; const rows = vectors[0].length; const m = new Matrix(rows, cols); let n = 0; for (let i = 0; i < cols; i++) { for (let j = 0; j < rows; j++) { m[n++] = vectors[i][j]; } } return m; } /** * Constructs a new instance of Matrix. If cols is omitted, it will mirror the rows * parameter, making a square matrix. * @param {number} rows number of rows * @param {number} cols number of columns * @param {number[]} values array of numbers to assign to the matrix elements * @param {boolean} rowsFirst if values should be read rows-first or columns-first * @param {boolean} mutateArgs set if the input array should be mutated or not */ constructor(rows = 4, cols, values, rowsFirst = true, mutateArgs = false) { cols = cols || rows; super(rows * cols); /** internal property to hold number of columns of this matrix */ this._c = cols; /** internal property to hold number of rows of this matrix */ this._r = rows; if (values) { if (values.length === 1 && Array.isArray(values[0])) { [values] = values; } this.copyFrom(values, rowsFirst, mutateArgs); } } /** * Set values of this matrix from an array * @param {number[]} values array of numbers * @param {boolean} rowsFirst if values should be read rows-first or columns-first * @param {number} mutateArgs */ copyFrom(values, rowsFirst = true, mutateArgs = false) { if (!rowsFirst) { for (let i = 0; i < Math.min(this.length, values.length); i++) { /** assign value */ this[i] = values[i]; } } else { if (values.length > this.length) { if (mutateArgs) { values.length = this.length; } else { values = values.slice(0, this.length); } } rowsToColumns(values, this.columns, this); } return this; } /** * Traverse this matrix * @param {function} callback function to be executed for each element * @param {boolean} rowsFirst if values should be read rows-first or columns-first * @return {Matrix} returns itself for chaining */ traverse(callback = () => ({}), rowsFirst = true) { Matrix.traverse(this, this.columns, callback, rowsFirst); return this; } /** * Clone/copy this matrix * @return {Matrix} */ clone() { return new Matrix(this.rows, this.columns, this, false); } /** * Calculate the internal 1d array index * @param {number} row row index (zero-based) * @param {number} col column index (zero-based) */ index(row, col) { return this.rows * col + row; } /** * Get a matrix element value by row and column * @param {number} row row index (zero-based) * @param {number} col column index (zero-based) * @return {number} */ get(row, col) { const idx = this.index(row, col); return this[idx]; } /** * Set a value at the specified row and column * @param {number} row row index (zero-based) * @param {number} col column index (zero-based) * @param {number} value value to set * @return {Matrix} returns itself for chaining */ set(row, col, value) { const idx = this.index(row, col); /** assign value */ this[idx] = value; return this; } /** * Calculate the matrix matrix product between this matrix and the passed matrices. * in the order they appear. * * The left hand matrix number of columns must always match the right hand matrix number of rows. * @param {...Matrix} matrices * @return {Matrix} */ dotMat(...matrices) { let m = this; let target = this; matrices.forEach((other) => { target = m.clone(); if (m.columns !== other.rows) throw Error('Columns of left hand matrix must match rows of right hand matrix!'); let idx = 0; for (let c = 0; c < other.columns; c++) { for (let r = 0; r < m.rows; r++) { let sum = 0; for (let n = 0; n < m.columns; n++) { sum += m.get(r, n) * other.get(n, c); } target[idx++] = sum; } } m = target; }); return target; } /** * Calculate the matrix vector product between this matrix and the passed arrays/vectors. * * Since it is common to use homogeneous coordinates when doing matrix-vector multiplication, * i.e. use 4x4 matrix for transforming 3d vectors, the vectors will be treated as if they had * the same number of components as the matrix has columns. For vectors with a lower dimension * than the number of columns in the matrix, the last component will be iterpreted as 1 and any * in between as 0. In the opposite case, it will simply neglect excessive components. * @param {number[]} vec vector (as Array/Vector) * @param {Vector|number[]} target optional array/vector to avoid mutating the vec argument * @return {number[]} resulting vector (type depending on vec/target argument) */ dotVec(vec, target = null) { if (target) { // optimized for immutable input vector for (let c = 0; c < this.columns; c++) { const n = c * this.rows; for (let r = 0; r < target.length; r++) { if (c === 0) target[r] = 0; let compVal = 0; if (c < vec.length) { compVal = vec[c]; } else if (c === this.rows - 1) { compVal = 1; } target[r] += this[n + r] * compVal; } } return target; } // optimized for mutation of input vector const comp = new Array(vec.length); for (let i = 0; i < vec.length; i++) { comp[i] = vec[i]; vec[i] = 0; } for (let c = 0; c < this.columns; c++) { const n = c * this.rows; for (let r = 0; r < vec.length; r++) { let compVal = 0; if (c < comp.length) { compVal = comp[c]; } else if (c === this.rows - 1) { compVal = 1; } vec[r] += this[n + r] * compVal; } } if (vec.length > this.rows) { vec.length = this.rows; } return vec; } /** * Calculate the matrix-matrix or matrix-vector product, depending on the type of * the argument passed to the other-parameter. * @param {number[]|Vector|Matrix} other {Array/Vector/Matrix} * @param {Vector|number[]} target optional array/vector to avoid mutating input argument * @return {Matrix|Vector|number[]} depending on input. */ dot(other, target = null) { if (other instanceof Matrix) { return this.dotMat(other); } return this.dotVec(other, target); } /** * Get the values from a specific column. * @param {number} j zero-based column index * @param {Vector|number[]} target optional array/vector to write values to * @return {number[]} column values */ col(j, target = null) { target = target || new Array(this.rows); const idx = j * this.rows; for (let i = idx; i < idx + this.rows; i++) { target[i - idx] = this[i]; } return target; } /** * Get the values from a specific row. * @param {number} i zero-based row index * @param {Vector|number[]} target optional array/vector to write values to * @return {number[]} row values */ row(i, target = null) { target = target || new Array(this.columns); for (let j = 0; j < this.columns; j++) { target[j] = this[i + j * this.rows]; } return target; } /** * Create a submatrix from this matrix. * @param {number} row zero-based row index * @param {number} col zero-based column index * @param {number} rows number of rows to include * @param {number} cols number of columns to include * @param {Matrix|number[]} target optional array/matrix to write values to * @return {Matrix} submatrix */ submatrix(row = 0, col = 0, rows = 2, cols = 2, target = null) { const start = this.index(row, col); const end = start + cols * this.rows; let subm; if (target) { if (target instanceof Matrix) { target._c = cols; target._r = rows; target.length = rows * cols; } subm = target; } else { subm = new Matrix(rows, cols); } let k = 0; for (let i = start; i < end; i += this.rows) { for (let j = 0; j < rows; j++) { subm[k++] = this[i + j]; } } return subm; } /** * Remove a row and/or column from this matrix * @param {number} row zero-based row index (-1 or null to omit) * @param {number} col zero-based column index (-1 or null to omit) * @param {Matrix} target optional matrix to avoid mutating this matrix * @return {Matrix} reduced matrix */ remove(row = null, col = null, target = null) { if (target && target instanceof Matrix) { target._r = this._r; target._c = this._c; target.length = this.length; target.copyFrom(this, false); } else { target = this; } let idx; if (Number.isFinite(col) && col >= 0 && col < target.columns) { idx = col * target.rows; target.splice(idx, target.rows); target._c--; } if (Number.isFinite(row) && row >= 0 && row < target.rows) { for (let r = 0; r < target.columns; r++) { idx = r * target.rows + row - r; target.splice(idx, 1); } target._r--; } return target; } /** * Transpose this matrix (switch rows and columns) * @param {Matrix|number[]} target optional array/matrix to avoid mutating this matrix * @return {Matrix} transposed matrix */ transpose(target = null) { const cols = this.rows; if (!target) { target = this; } else { target.length = this.length; } if (target instanceof Matrix) { target._r = this._c; target._c = cols; } rowsToColumns(this, cols, target); return target; } /** * Invert this matrix (where applicable) * @param {Matrix} target optional matrix to avoid mutating this matrix * @return {Matrix} transposed matrix */ inverse(target = null) { if (!this.isSquare) throw Error('Matrix must be square!'); const dim = this.rows; if (target && target instanceof Matrix) { target._c = this.columns; target._r = this.rows; target.length = this.length; target.copyFrom(this, false); } else { target = this; } const src = Matrix.identity(dim); for (let i = 0; i < dim; i++) { const d = target.index(i, i); let e = target[d]; // if we have a 0 on the diagonal (we'll need to swap with a lower row) if (e === 0) { // look through every row below the i'th row for (let ii = i + 1; ii < dim; ii += 1) { // if the ii'th row has a non-0 in the i'th col if (target.get(ii, i) !== 0) { // it would make the diagonal have a non-0 so swap it for (let j = 0; j < dim; j++) { const ij = target.index(i, j); const iij = target.index(ii, j); e = target[ij]; // temp store i'th row target[ij] = target[iij]; // replace i'th row by ii'th target[iij] = e; // repace ii'th by temp e = src[ij]; // temp store i'th row src[ij] = src[iij]; // replace i'th row by ii'th src[iij] = e; // repace ii'th by temp } // don't bother checking other rows since we've swapped break; } } // get the new diagonal e = target[d]; // if it's still 0, not srcertable (error) if (e === 0) return undefined; } // Scale this row down by e (so we have a 1 on the diagonal) for (let j = 0; j < dim; j++) { const ij = target.index(i, j); target[ij] /= e; // apply to original thisrix src[ij] /= e; // apply to identity } // Subtract this row (scaled appropriately for each row) from ALL of // the other rows so that there will be 0's in this column in the // rows above and below this one for (let ii = 0; ii < dim; ii++) { // Only apply to other rows (we want a 1 on the diagonal) if (ii === i) continue; // We want to change this element to 0 e = target.get(ii, i); // Subtract (the row above(or below) scaled by e) from (the // current row) but start at the i'th column and assume all the // stuff left of diagonal is 0 (which it should be if we made this // algorithm correctly) for (let j = 0; j < dim; j++) { const ij = target.index(i, j); const iij = target.index(ii, j); target[iij] -= e * target[ij]; // apply to original matrix src[iij] -= e * src[ij]; // apply to identity } } } return src; } /** * Calculate this matrix's determinant (where applicable) * @return {number} the determinant */ determinant() { if (!this.isSquare) throw Error('Matrix must be square!'); if (this.rows === 2) { return this[0] * this[3] - this[2] * this[1]; } else if (this.rows === 3) { return this[0] * this[4] * this[8] - this[6] * this[4] * this[2] + this[3] * this[7] * this[2] - this[0] * this[7] * this[5] + this[6] * this[1] * this[5] - this[3] * this[1] * this[8]; } function determinantRec(m) { if (m.length === 1) return m[0]; let d = 0; for (let c = 0; c < m.columns; c++) { const v = m[c * m.rows]; if (v === 0) continue; const sm = m.remove(0, c, new Matrix()); let cofactor = determinantRec(sm); if (c % 2 === 1) { cofactor = -cofactor; } d += v * cofactor; } return d; } return determinantRec(this); } /** * Scale this vector by a factor * @param {number} factor scaling factor * @param {Matrix|number[]} target optional array/matrix to avoid mutating this matrix * @return {Matrix} */ scale(factor, target = null) { return scale(this, factor, target || this); } /** * Returns a native javascript Array representation of this matrix, in rows-first order * @return {number[]} */ columnsFirst() { return [...this]; } /** * Returns a native javascript Array representation of this matrix, in column-first order * @return {number[]} */ rowsFirst() { const res = new Array(this.length); rowsToColumns(this, this.rows, res); return res; } /** * Return a native javascript Array representation of this matrix. * @param {boolean} rowsFirst if the output should be rows-first or columns-first * @return {number[]} */ toArray(rowsFirst = false) { return rowsFirst ? this.rowsFirst() : this.columnsFirst(); } /** * Returns a 2d native javascript Array representation of this matrix. * @param {boolean} rowsFirst if the output should be rows-first or columns-first * @return {Array} */ toArray2d(rowsFirst = false) { const res = new Array(rowsFirst ? this.rows : this.columns); const cf = rowsFirst ? (v, i, r, c) => { if (!res[r]) res[r] = new Array(this.columns); res[r][c] = v; } : (v, i, r, c) => { if (!res[c]) res[c] = new Array(this.rows); res[c][r] = v; }; this.traverse(cf); return res; } /** * Get the number of columns in this matrix. * @return {number} */ get columns() { return this._c; } /** * Get the number of rows in this matrix. * @return {number} */ get rows() { return this._r; } /** * This function returns true if this matrix has the same number of rows as columns, * otherwise false. * @return {boolan} */ get isSquare() { return this.rows === this.columns; } } // add extra accessors for (let i = 1; i <= 4; i++) { for (let j = 1; j <= 4; j++) { Object.defineProperty(Matrix.prototype, `a${i}${j}`, { get() { return this.get(i - 1, j - 1); }, set(v) { this.set(i - 1, j - 1, v); }, }); } } return Matrix; }33:T479,clamp = { /** * Clamps each value in array according to min and max. * @param {number[]} arr values to clamp * @param {number} min minimum value * @param {number} max maximum value * @param {number[]} target optional array/vector to store the result * @return {number[]} array of clamped values */ function clampArray(arr, min = 0, max = 1, target = null) { target = target || arr; for (let i = 0; i < target.length; i++) { target[i] = clampValue(target[i], min, max); } return target; } /** * Clamps the argument according to min and max. Arg can be either a numeric * value or an array of numeric values. * @param {number|number[]} arg value or array of values to clamp * @param {number} min minimum value * @param {number} max maximum value * @param {number[]} target optional array/vector to store the result * @return {number|number[]} clamped version of arg */ function clamp(arg, min = 0, max = 1, target = null) { if (Array.isArray(arg)) { return clampArray(arg, min, max, target); } return clampValue(arg, min, max); } return clamp; }34:T529,step = { /** * As glsl step function for single numeric values * @param {number} edge value to test * @param {number} x threshold value * @return {number} returns 0 or 1 */ function stepValue(edge, x) { return x >= edge ? 1 : 0; } /** * As glsl step function for multiple numeric values * @param {number[]} edges values to test * @param {number|number[]} x threshold values * @param {number[]} target optional array/vector to store the result * @return {number[]} results for each value in edges */ function stepArray(edges, x, target = null) { const m = Array.isArray(x) ? i => x[i] : () => x; target = target || edges; for (let i = 0; i < target.length; i++) { target[i] = stepValue(target[i], m(i)); } return target; } /** * Implementation of glsl step function. Returns 0 if an edge is less than the * threshold x, otherwise 1 * @param {number|number[]} edge number/array to test * @param {number|number[]} x threshold(s) * @param {number[]} target optional array/vector to store the result (if edge is array) * @return {number|number[]} */ function step(edge, x, target = null) { if (Array.isArray(edge)) { return stepArray(edge, x, target); } return stepValue(edge, x); } return step; }35:[] 2f:{"id":"9c6c135be8f36563","slug":"linear-algebra","title":"Linear Algebra","thumbnail":"dd8ccbadc938210f2af83f6effdf022b94a2683684f8f04d2bed8bfb9e87f47c","access_level":"public","create_time":"$D2019-05-14T13:22:01.267Z","update_time":"$D2023-03-09T12:09:17.176Z","view_time":null,"first_public_time":"$D2019-05-14T19:54:29.519Z","fork":false,"stars":7,"starred":false,"owner":{"type":"team","id":"455184b0afc7f1fd","login":"kjerandp","name":"Kjerand Pedersen","avatar_url":"https://avatars-next.observableusercontent.com/3c52e0775a9b4937e6002e09ca22d564189c0d589cae2166e091b5fe3b7f2458","tier":"starter_2024"},"version":1223,"publish_version":null,"role":null,"authored":false,"authors":[{"type":"individual","id":"00080969d76f924b","login":"kjerandp","name":"Kjerand Pedersen","avatar_url":"https://avatars-next.observableusercontent.com/3c52e0775a9b4937e6002e09ca22d564189c0d589cae2166e091b5fe3b7f2458","tier":null}],"members":[{"type":"individual","id":"00080969d76f924b","login":"kjerandp","name":"Kjerand Pedersen","avatar_url":"https://avatars-next.observableusercontent.com/3c52e0775a9b4937e6002e09ca22d564189c0d589cae2166e091b5fe3b7f2458","tier":null,"role":"editor"}],"comments":[],"custom_thumbnail":false,"trashed":false,"subscribed":null,"forks":3,"collection":{"id":"fc9d59b1d3947635","slug":"libs","title":"Libs/reusable","owner":{"id":"455184b0afc7f1fd","login":"kjerandp","name":"Kjerand Pedersen"}},"type":"notebook","body":{"title":"Linear Algebra","cells":[{"id":0,"value":"md`# Linear Algebra`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":173,"value":"Useful functions for basic linear-algebra...\n\nExamples:\n\nhttps://observablehq.com/@kjerandp/using-linear-algebra\nhttps://observablehq.com/@kjerandp/affine-transformations","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1216,"value":"How to import: \n```js\nimport {\n vec3,\n mat4,\n mix,\n printMatrix,\n ...\n} from '@kjerandp/linear-algebra'\n```","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":257,"value":"md`#### Types`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1107,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":109,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":274,"value":"md`#### Arithmetic and utility functions`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":323,"value":"/**\n * Component-wise addition of two arrays/vectors.\n * If target is NOT specified, the first argument will\n * be mutated. Target will be overwritten and NOT included in the sum.\n * @param {number[]} to left operand\n * @param {number[]} from right operand\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} array/vector\n */\nfunction add(to, from, target = null) {\n if (target) {\n if (target.length === 0) target.length = to.length;\n } else {\n target = to;\n }\n for (let i = 0; i < target.length; i++) {\n target[i] = to[i] + from[i];\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":910,"value":"/**\n * Component-wise addition of a set of arrays/vectors.\n * If target is NOT specified, the first element in the set will\n * be mutated. Target (if it has valid values) WILL be included in the sum.\n * @param {number[][]} vectors Array of equally length arrays/vectors (to be added)\n * @param {number[]} target optional array/vector to add into\n * @return {number[]} array/vector\n */\nfunction addAll(vectors, target = null) {\n let start = 0;\n if (!target) {\n target = vectors[0];\n start++;\n }\n\n for (let i = start; i < vectors.length; i++) {\n for (let j = 0; j < vectors[i].length; j++) {\n if (i === 0 && !Number.isFinite(target[j])) {\n target[j] = vectors[i][j];\n } else {\n target[j] += vectors[i][j];\n }\n }\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":925,"value":"/**\n * Component-wise addition of one vector with a scaled version of another vector.\n * If target is NOT specified, the first argument will\n * be mutated. Target will be overwritten and NOT included in the sum.\n * @param {number[]} to left operand\n * @param {number[]} from right operand\n * @param {number} factor scaling factor to apply to from-vector\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} array/vector\n */\nfunction addScaled(to, from, factor, target = null) {\n if (target) {\n if (target.length === 0) target.length = to.length;\n } else {\n target = to;\n }\n for (let i = 0; i < target.length; i++) {\n target[i] = to[i] + from[i] * factor;\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":324,"value":"/**\n * Component-wise subtraction of two arrays/vectors.\n * If target is NOT specified, the first argument will\n * be mutated. Target will be overwritten and NOT included in the sum.\n * @param {number[]} from left operand\n * @param {number[]} vector right operand\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} array/vector\n */\nfunction sub(from, vector, target = null) {\n if (target) {\n if (target.length === 0) target.length = from.length;\n } else {\n target = from;\n }\n for (let i = 0; i < target.length; i++) {\n target[i] = from[i] - vector[i];\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":915,"value":"/**\n * Component-wise subtraction of array/vector and all elements in vectors.\n * If target is NOT specified, the first argument will\n * be mutated. Target will be overwritten and NOT included in the sum.\n * @param {number[]} from left operand\n * @param {number[][]} vectors right operand\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} array/vector\n */\nfunction subAll(from, vectors, target = null) {\n if (target) {\n if (target.length === 0) target.length = from.length;\n } else {\n target = from;\n }\n\n for (let i = 0; i < vectors.length; i++) {\n for (let j = 0; j < vectors[i].length; j++) {\n if (i === 0) {\n target[j] = from[j] - vectors[i][j];\n } else {\n target[j] -= vectors[i][j];\n }\n }\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":928,"value":"/**\n * Component-wise addition of one vector with a scaled version of another vector.\n * If target is NOT specified, the first argument will\n * be mutated. Target will be overwritten and NOT included in the sum.\n * @param {number[]} from left operand\n * @param {number[]} vector right operand\n * @param {number} factor scaling factor to apply to vector that will be subtracted\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} array/vector\n */\nfunction subScaled(from, vector, factor, target = null) {\n if (target) {\n if (target.length === 0) target.length = from.length;\n } else {\n target = from;\n }\n for (let i = 0; i < target.length; i++) {\n target[i] = from[i] - vector[i] * factor;\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":326,"value":"/**\n * Component-wise scaling of an array or vector\n * @param {number[]} arr array/vector to scale\n * @param {number} factor scaling factor\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} scaled array/vector\n */\nfunction scale(arr, factor, target = null) {\n target = target || arr;\n for (let i = 0; i < arr.length; i++) {\n target[i] = arr[i] * factor;\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":773,"value":"/**\n * Computes the sum of squares\n * @param {number[]} arr array/vector to compute\n * @return {number}\n */\nfunction sumsqr(arr) {\n return arr.reduce((sum, v) => sum + v ** 2, 0);\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":776,"value":"/**\n * Computes the scalar value (length) of a vector\n * @param {number[]} vector array/vector to compute\n * @return {number}\n */\nfunction scalar(vector) {\n const sq = sumsqr(vector);\n if (sq === 0) return sq;\n return Math.sqrt(sq);\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":209,"value":"/**\n * Normalizes an array/vector\n * @param {number[]} vector array/vector to notmalize\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} normalized array/vector\n */\nfunction norm(vector, target = null) {\n target = target || vector;\n const sc = scalar(vector);\n const f = sc === 0 ? 0 : 1 / sc;\n return scale(vector, f, target);\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":780,"value":"/**\n * Get a unit vector that is perpendicular to the input vector. Only for 2d vectors!\n * @param {number[]} vector 2d vector\n * @param {number[]} target optional array/vector to store the resulting vector\n * @return {number[]} normalized, perpendicular vector\n */\nfunction orth2(vector, target = null) {\n target = target || vector;\n const x = -vector[1];\n target[1] = vector[0];\n target[0] = x;\n return norm(target);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":783,"value":"/**\n * Get a unit vector between two points/coordinates. This function\n * does not mutate any arguments, but a target may still be used to\n * control the return type or to avoid creating additional arrays.\n * @param {number[]} from start coordinates\n * @param {number[]} to end coordinates\n * @param {number[]} target optional array/vector to store the resulting vector\n * @return {number[]} unit vector between from and to\n */\nfunction dir(from, to, target = null) {\n return norm(vec(from, to, target));\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":786,"value":"/**\n * Calculate the distance between two points/coordinates.\n * @param {number[]} p1 point/coordinates\n * @param {number[]} p2 point/coordinates\n * @return {number} distance\n */\nfunction dist(p1, p2) {\n return scalar(vec(p1, p2));\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":155,"value":"/**\n * Calculate the dot product between two vectors\n * @param {number[]} v1 left hand operand\n * @param {number[]} v2 right hand operand\n * @return {number} the dot product\n */\nfunction dot(v1, v2) {\n return v1.reduce((sum, c, i) => sum + c * v2[i], 0);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":158,"value":"/**\n * Find the cross product between two 3d vectors\n * @param {number[]} v1 left hand operand (3d vector)\n * @param {number[]} v2 right hand operand (3d vector)\n * @param {number[]} target optional array/vector to store the resulting vector\n * @return {number[]} the cross product vector (normal)\n */\nfunction cross(v1, v2, target = null) {\n target = target || new Array(3);\n target[0] = (v1[1] * v2[2]) - (v1[2] * v2[1]);\n target[1] = (v1[2] * v2[0]) - (v1[0] * v2[2]);\n target[2] = (v1[0] * v2[1]) - (v1[1] * v2[0]);\n\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":792,"value":"/**\n * Find the psudo cross product between two 2d vectors\n * @param {number[]} v1 left hand operand (2d vector)\n * @param {number[]} v2 right hand operand (2d vector)\n * @return {number} signed area of the parallellogram defined by v1 and v2\n */\nfunction cross2(v1, v2) {\n return (v1[0] * v2[1]) - (v1[1] * v2[0]);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":161,"value":"/**\n * Get the triple product between three 3d vectors\n * @param {number[]} v1 left hand operand for the dot product (3d vector)\n * @param {number[]} v2 left hand operand for the cross product (3d vector)\n * @param {number[]} v3 right hand operand for the cross product (3d vector)\n * @return {number} triple product\n */\nfunction triple(v1, v2, v3) {\n return dot(v1, cross(v2, v3));\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":151,"value":"$33","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1092,"value":"/**\n * Clamps the value to min or max if value is less than min or greater than max\n * @param {number} value value to clamp\n * @param {number} min minimum value\n * @param {number} max maximum value\n * @return {number} clamped value\n */\nfunction clampValue(value, min = 0, max = 1) {\n if (value < min) return min;\n if (value > max) return max;\n return value;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":212,"value":"$34","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":215,"value":"/**\n * Implementation of glsl smoothstep function\n * @param {number} edge0\n * @param {number} edge1\n * @param {number} x threshold\n */\nfunction smoothstep(edge0, edge1, x) {\n const t = clampValue((x - edge0) / (edge1 - edge0));\n return t * t * (3.0 - 2.0 * t);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":797,"value":"/**\n * Linear interpolation between two numbers\n * @param {number} a interpolate from\n * @param {number} b interpolate to\n * @param {number} t time 0 = a, 1 = b\n * @return {number} the interpolated value\n */\nfunction lerp(a, b, t) {\n const m = clampValue(t, 0, 1);\n return a * (1 - m) + b * m;\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":149,"value":"/**\n * Mix (interpolate) numbers or arrays (similar to glsl implementation).\n * Works on both vectors and matrices, since they are both arrays.\n * @param {number[]} a interpolate from\n * @param {number[]} b interpolate to\n * @param {number|number[]} t time 0 = a, 1 = b\n * @param {number[]} target optional array/vector to store the result\n * @return {number[]} interpolated array/vector/matrix\n */\nfunction mix(a, b, t, target = null) {\n const m = Array.isArray(t) ? i => t[i] : () => t;\n target = target || a;\n for (let i = 0; i < target.length; i++) {\n target[i] = lerp(a[i], b[i], m(i));\n }\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":674,"value":"/**\n * Rounds a number to the specific number of digits. Works with either a\n * single number or an array of numbers, which means it can be used with vectors and\n * matrices as well.\n * @param {number|number[]} v value to round\n * @param {number} digits number of digits to round to\n * @return {number} rounded value\n */\nfunction round(v, digits = 1) {\n const f = 10 ** digits;\n if (!Array.isArray(v)) {\n return Math.round(v * f) / f;\n }\n for (let i = 0; i < v.length; i++) {\n v[i] = Math.round(v[i] * f) / f;\n }\n return v;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":890,"value":"/**\n * Find the axis aligned angle of a 2d vector\n * @param {number[]} vector\n * @return {number} angle in radians\n */\nfunction angle2(vector) {\n return Math.atan2(vector[1], vector[0]);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":893,"value":"/**\n * Find the axis aligned angle of a 3d vector\n * @param {number[]} vector\n * @param {number} axis which axis to measure from X=0, Y=1, Z=2 (defaults to 0)\n * @return {number} angle in radians\n */\nfunction angle(vector, axis = 0) {\n if (axis > 2 || axis < 0) return undefined;\n\n const [x, y, z] = vector;\n let a, b, c;\n switch (axis) {\n case 0: a = y; b = z; c = x; break;\n case 1: a = x; b = z; c = y; break;\n default: a = x; b = y; c = z;\n }\n const l = Math.sqrt(a ** 2 + b ** 2);\n return Math.atan2(l, c);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":902,"value":"/**\n * Describes relationships between two points.\n * @param {number[]} from start coordinates\n * @param {number[]} to end coordinates\n * @param {number[]} target optional array/vector to store the result\n * @return {{vector: number[], sqr: number, distance: number, unit: number[]}}\n */\nfunction descr(from, to, target = null) {\n if (!target) {\n target = to.slice();\n } else {\n if (target.length === 0) {\n target.length = to.length;\n }\n for (let i = 0; i < target.length; i++) {\n target[i] = to[i];\n }\n }\n const vector = sub(target, from);\n const sqr = sumsqr(vector);\n const dst = Math.sqrt(sqr);\n const unit = scale(vector, dst > 0 ? 1 / dst : 0, vector.slice());\n return {\n vector,\n sqr,\n dist: dst,\n unit,\n };\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1024,"value":"/**\n * Generates a list of interpolated values between from and to,\n * where the number of elements returned are controlled by the\n * steps argument.\n * @param {number|number[]} from value to interpolate from\n * @param {number|number[]} to value to interpolate to\n * @param {number} steps interpolation steps\n * @param {number} start start time of interpolation [0-1]\n * @param {number} end end time of interpolation [0-1]\n */\nfunction seq(from, to, steps, start = 0, end = 1) {\n let f;\n if (Array.isArray(from)) {\n f = t => mix(from, to, t, from.slice());\n } else {\n f = t => lerp(from, to, t);\n }\n const target = [];\n const incr = (end - start) / (steps - 1);\n for (let i = 0; i < steps - 1; i++) {\n const x = start + i * incr;\n target.push(f(x));\n }\n target.push(f(end));\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1086,"value":"/**\n * Generates a list of interpolated values between 0 and 1,\n * where the number of elements returned are controlled by the\n * steps argument.\n * @param {number} steps interpolation steps\n */\nfunction seqI(steps) {\n const target = [];\n const incr = 1 / (steps - 1);\n for (let i = 0; i < steps - 1; i++) {\n target.push(lerp(0, 1, i * incr));\n }\n target.push(1);\n return target;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1089,"value":"/**\n * Test if a vector is a null vector\n * @param {number[]} v vector to test\n * @param {number} epsilon optional epsilon value\n */\nfunction isNullVec(v, epsilon = 0) {\n return epsilon ? v.every(val => Math.abs(val) - epsilon <= 0) : v.every(val => val === 0);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":230,"value":"md`#### Conversion functions`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":179,"value":"/**\n * Convert radians to degrees\n * @param {number} r radians\n * @returns {number} degrees\n */\nfunction deg(r) {\n return r * RAD2DEG;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":177,"value":"/**\n * Convert degrees to radians\n * @param {number} d degrees\n * @returns {number} radians\n */\nfunction rad(d) {\n return d * DEG2RAD;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":206,"value":"/**\n * Normalise an angle to be between -PI to +PI\n * @param {number} r radians\n * @return {number} normalised angle\n */\nfunction nrad(r) {\n const v = r % TAU;\n return (v < 0 ? v + TAU : v);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":170,"value":"md`#### Factory functions`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":896,"value":"/**\n * Create a vector from two points. This function will NOT mutate any\n * arguments unless 'target' is the same as 'from'.\n * @param {number[]} from start coordinates\n * @param {number[]} to end coordinates\n * @param {number[]} target optional array/vector to store the resulting vector\n * @return {number[]} vector\n */\nfunction vec(from, to, target = null) {\n if (!target) {\n target = to.slice();\n } else {\n if (target.length === 0) {\n target.length = to.length;\n }\n for (let i = 0; i < target.length; i++) {\n target[i] = to[i];\n }\n }\n return sub(target, from);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":899,"value":"/**\n * Create a vector of specific dimension and optionally set its values.\n * If values contains only one element, the all components will be set to\n * this value. Elements in values exceeding the specified dimension will\n * be neglected.\n * @param {number} dim the number of components\n * @param {Array} values optional initial values\n * @return {Vector}\n */\nfunction nvec(dim = 0, values = [0]) {\n if (values.length === 1 && Number.isFinite(values[0])) {\n return new Vector(dim).fill(values[0]);\n }\n const v = new Vector();\n flattenList(values, v, dim);\n for (let i = v.length; i < dim; i++) {\n v.push(0);\n }\n return v;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":113,"value":"/**\n * Factory function for creating and assigning a 2d vector. If a single\n * argument is passed, then all components will be assigned with its value.\n * Missing initial values will be filled with zeros.\n * @param {...number} args initial values\n * @return {Vector}\n */\nfunction vec2(...args) {\n return nvec(2, args);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":116,"value":"/**\n * Factory function for creating and assigning a 3d vector. If a single\n * argument is passed, then all components will be assigned with its value.\n * Missing initial values will be filled with zeros.\n * @param {...number} args initial values\n * @return {Vector}\n */\nfunction vec3(...args) {\n return nvec(3, args);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":119,"value":"/**\n * Factory function for creating and assigning a 4d vector. If a single\n * argument is passed, then all components will be assigned with its value.\n * Missing initial values will be filled with zeros.\n * @param {...number} args initial values\n * @return {Vector}\n */\nfunction vec4(...args) {\n return nvec(4, args);\n}\n","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1119,"value":"/**\n * Factory function for creating and assigning a matrix from an array.\n * The array must be 1 dimensional, and will be split into rows and columns based\n * on the specified cols parameter. If array length divided by cols doesn't add up\n * to a whole number, then only floor(args.length / cols) values will be read from\n * the input array.\n *\n * Initial values are passed in row-first order by default, but can optionally\n * be passed in columns-first by setting the rowFirst argument to false.\n * @param {...number} arr initial values\n * @param {number} cols number of columns to split the array into\n * @param {boolean} rowsFirst read arr in rows-first or column-first order\n * @return {Matrix}\n */\nfunction mat(arr, cols, rowsFirst = true) {\n return Matrix.fromArray(arr, cols, rowsFirst, true);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":122,"value":"/**\n * Factory function for creating and assigning a 2x2 matrix.\n * Initial values are passed in row-first order.\n * @param {...number} args initial values\n * @return {Matrix}\n */\nfunction mat2(...args) {\n return new Matrix(2, 2, args, true, true);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":125,"value":"/**\n * Factory function for creating and assigning a 3x3 matrix.\n * Initial values are passed in row-first order.\n * @param {...number} args initial values\n * @return {Matrix}\n */\nfunction mat3(...args) {\n return new Matrix(3, 3, args, true, true);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":128,"value":"/**\n * Factory function for creating and assigning a 4x4 matrix.\n * Initial values are passed in row-first order.\n * @param {...number} args initial values\n * @return {Matrix}\n */\nfunction mat4(...args) {\n return new Matrix(4, 4, args, true, true);\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":343,"value":"md`### Constants`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":349,"value":"PI = Math.PI","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":345,"value":"TAU = 2 * Math.PI","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":352,"value":"SPI = Math.PI / 2","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":355,"value":"QPI = Math.PI / 4","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1185,"value":"RAD2DEG = 180 / Math.PI","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1188,"value":"DEG2RAD = Math.PI / 180","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":814,"value":"md`### Added utils`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1135,"value":"flattenList = {\n /**\n * Recursive function used by flattenList\n * @param {number[]} array array to be flattended\n * @param {number[]} flattend resulting array of values\n * @param {number} max max returned values (default is 0 for all)\n */\n function flatRec(array, flattend, max) {\n for (let i = 0; i < array.length; i++) {\n if (max && flattend.length === max) return;\n const el = array[i];\n if (Array.isArray(el)) flatRec(el, flattend, max);\n else flattend.push(el);\n }\n }\n \n /**\n * Recursivly flattens a list of arguments to a 1 dimensional array\n * @param {number[]} arg Arguments to be flattended\n * @param {number[]} flattend Resulting array of values\n * @param {number} max Max returned values (default is 0 for all)\n */\n function flattenList(arg = [], flattend = [], max = 0) {\n if (flattend.length > 0) flattend.length = 0;\n flatRec(arg, flattend, max);\n return flattend;\n }\n\n return flattenList;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":289,"value":"printMatrix = m => tex`${latex_matrix(m.toArray2d(true))}`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":193,"value":"md`### Lib/imports`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":282,"value":"import {latex_matrix} from \"@sorig/latex_matrix\"","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"}],"files":"$W35","stdlib":"1","titling":"auto"}} 30:"$2f:body"