30:T7fb,histogram = function(array, bins, {range=null, weights=null}={}) { let bin_edges; if(typeof bins[Symbol.iterator] === "function") { bin_edges = array.constructor.from(bins); } else if(bins.hasOwnProperty("length")) { if(range != null) throw Error("range cannot be specified when bins is an array."); bin_edges = bins; } else { if(range == null) range = [Math.min(...array), Math.max(...array)]; const binsize = (range[1] - range[0]) / bins; // Will have the same type as array. bin_edges = array.constructor.from(linspace(range[0], range[1], bins + 1)); } if(weights != null && weights.length != array.length) { throw Error("Expected weights.length == " + array.length); } // Initialize the histogram counts. const ctor = weights == null ? array.constructor : weights.constructor; let hist = new ctor(bin_edges.length - 1).fill(0); // Convert the bin edges into {x:x, bin:i} objects. bins = Array.from(bin_edges).map((x,i) => Object.fromEntries([['x',x], ['bin', i]])); // Convert the input array into {x:x, bin:null} objects. array = Array.from(array).map((x,i) => Object.fromEntries([['x',x], ['bin', null]])); // Add wgt attributes if weights are provided. if(weights != null) array = array.map((a,i) => Object.assign(a, {wgt:weights[i]})); // Merge the data and the bin edges into a single array sorted on x. const merged = bins.concat(array).sort((a,b) => (a.x-b.x)); // Select the bin edges labeled with their index in the merged array. const edges = merged .map((a,i) => a.bin == null ? a : Object.assign(a, {index:i})) .filter(a => a.bin != null); // Sum the weights in each bin. for(let i=0; i < edges.length - 1; i++) { const lo=edges[i], hi=edges[i+1]; if(weights == null) { // Count the entries. hist[i] = hi.index - lo.index - 1; } else { // Sum the weights. hist[i] = merged.slice(lo.index+1, hi.index).reduce((wgtsum, a) => wgtsum + a.wgt, 0); } } return {hist: hist, bin_edges: bin_edges}; }31:Ta15,interp = function(x, xp, fp, {clipped=false}={}) { if(xp.length != fp.length) throw new Error('Inputs xp,fp must have the same length'); const np = xp.length; if(np == 1) throw new Error('Inputs xp,fp must have length > 1.'); const sign = Math.sign(xp[1] - xp[0]); if(sign == 0 || !xp.every((_,i,a) => i==0 || Math.sign(a[i] - a[i-1]) == sign)) { throw new Error('Values of xp must be increasing or decreasing.'); } // Pack (xp,fp) into a single array with elements {x:xp[i], f:fp[i]}. const packed = Array.from({length: np}, (_,i) => ({x:xp[i], f:fp[i]})); // If x is a scalar, wrap it into an array. const scalar = (typeof x == 'number'); if(scalar) x = [x]; // Allocate the result array. let f = new x.constructor(x.length); // Check for out of bounds x values and clip if requested. const [xmin, xmax] = [Math.min(...x), Math.max(...x)]; const [xpmin, xpmax] = sign > 0 ? [xp[0], xp[np-1]] : [xp[np-1], xp[0]]; if(!clipped && (xmin < xpmin)) throw new Error('Expected min(x) >= min(xp) or {clipped:true}.'); if(!clipped && (xmax > xpmax)) throw new Error('Expected max(x) <= max(xp) or {clipped:true}.'); // Extend x into an array with elements {x:x[i], f:null, src:i}. const expanded = Array.from(x).map((x,i) => ({x:x, f:null, src:i})); // Merge the input x values into the same array and sort on the x key. let merged = packed.concat(expanded).sort((a,b) => a.x - b.x); // Add the index position in the merged array to the original (xp,fp) entries. merged = merged.map((a,i) => a.f == null ? a : Object.assign(a, {index:i})); // Pick out the (xp,fp) nodes. const nodes = merged.filter(a => a.f != null); // Process any initial x < min(xp), which should only happen when clipped is true. const first = nodes[0]; if(!clipped && first.index > 0) throw new Error('Internal error: !clipped && min(x) < min(xp).'); for(let j=0; j= max(xp). const last=nodes[np-1]; for(let j=last.index+1; j Math.sin(x))\\`.\n\nTo use any of these routines in your own notebooks, use e.g.\n\\`\\`\\`\n import {linspace,interp} from '@dkirkby/jumpy'\n\\`\\`\\`\n\nThese are only intended as a temporary crutch while you learn the corresponding javascript idioms and libraries. Most of this is best done using the excellent [d3.array](https://github.com/d3/d3-array) library that is built into Observable.\n`","pinned":false,"hidden":false,"mode":"ojs"},{"id":267,"value":"md`## Array Creation\n\nCreate arrays using these numpy-like functions. The default return value is a \\`Float64Array\\` [typed array]((https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/TypedArray) unless you specify a \\`dtype\\`:`","pinned":false,"hidden":false,"mode":"ojs"},{"id":285,"value":"arange(5)","pinned":true,"hidden":false,"mode":"ojs"},{"id":512,"value":"arange(5, {dtype:Int32Array})","pinned":true,"hidden":false,"mode":"ojs"},{"id":514,"value":"arange(5, {dtype:Array})","pinned":true,"hidden":false,"mode":"ojs"},{"id":281,"value":"arange(5, {start: 1, step:0.5})","pinned":true,"hidden":false,"mode":"ojs"},{"id":301,"value":"md`Similarly for the other functions:`","pinned":false,"hidden":false,"mode":"ojs"},{"id":448,"value":"zeros(3)","pinned":true,"hidden":false,"mode":"ojs"},{"id":455,"value":"ones(3)","pinned":true,"hidden":false,"mode":"ojs"},{"id":304,"value":"linspace(0, 1, 6)","pinned":true,"hidden":false,"mode":"ojs"},{"id":681,"value":"linspace(1, 0, 6)","pinned":true,"hidden":false,"mode":"ojs"},{"id":623,"value":"logspace(-2, 3, 6)","pinned":true,"hidden":false,"mode":"ojs"},{"id":752,"value":"geomspace(1e-2, 1e3, 6)","pinned":true,"hidden":false,"mode":"ojs"},{"id":299,"value":"md`## Array Calculations\n\nThese examples should hopefully be self explanatory. Note that \\`diff\\` and \\`cumsum\\` return the same type as their input by default:`","pinned":false,"hidden":false,"mode":"ojs"},{"id":351,"value":"cumsum(arange(5, {dtype:Int32Array}))","pinned":true,"hidden":false,"mode":"ojs"},{"id":532,"value":"cumsum(arange(5, {dtype:Int32Array}), {dtype:Float32Array})","pinned":true,"hidden":false,"mode":"ojs"},{"id":320,"value":"x = linspace(0, 10, 1001)","pinned":true,"hidden":false,"mode":"ojs"},{"id":322,"value":"y = x.map(x => Math.sin(x))","pinned":true,"hidden":false,"mode":"ojs"},{"id":327,"value":"diff(y)","pinned":true,"hidden":false,"mode":"ojs"},{"id":329,"value":"cumsum(y)","pinned":true,"hidden":false,"mode":"ojs"},{"id":331,"value":"argsort(y)","pinned":true,"hidden":false,"mode":"ojs"},{"id":334,"value":"interp([Math.PI / 2, Math.PI / 4], x, y)","pinned":true,"hidden":false,"mode":"ojs"},{"id":630,"value":"// scalar first arg gives a scalar result\ninterp(1, x, y)","pinned":true,"hidden":false,"mode":"ojs"},{"id":725,"value":"// xp can be decreasing\ninterp(1, [2,1,0],[5,6,7])","pinned":true,"hidden":false,"mode":"ojs"},{"id":727,"value":"// x can be clipped to the limits of xp\ninterp([-1,3],[0,1,2],[5,6,7],{clipped:true})","pinned":true,"hidden":false,"mode":"ojs"},{"id":476,"value":"data = Float64Array.from({length: 1000}, a => Math.random());","pinned":true,"hidden":false,"mode":"ojs"},{"id":365,"value":"histogram(data, 10, {range:[0,1]})","pinned":true,"hidden":false,"mode":"ojs"},{"id":433,"value":"histogram(data, 10, {range:[0,1], weights:data.map(x => x**2)})","pinned":true,"hidden":false,"mode":"ojs"},{"id":466,"value":"histogram(data, linspace(0, 1, 11)).hist","pinned":true,"hidden":false,"mode":"ojs"},{"id":595,"value":"{\n const data = [0,2,-1,1];\n return {max:argmax(data), min:argmin(data)};\n}","pinned":true,"hidden":false,"mode":"ojs"},{"id":612,"value":"md`The \\`meshgrid\\` function converts an array of coordinate vectors into a dense rectangular grid of coordinate values. By default, the result is nested but a flattened result can also be constructed directly without creating any temporary arrays:`","pinned":false,"hidden":false,"mode":"ojs"},{"id":603,"value":"meshgrid([[-1,1],[-2,0,2]])","pinned":true,"hidden":false,"mode":"ojs"},{"id":605,"value":"meshgrid([[-1,1],[-2,0,2]]).flat(2);","pinned":true,"hidden":false,"mode":"ojs"},{"id":609,"value":"meshgrid([[-1,1],[-2,0,2]], {flat:true, dtype:Float32Array})","pinned":true,"hidden":false,"mode":"ojs"},{"id":734,"value":"meshgrid([new Int32Array([-1,1]), new Int32Array([-2,0,2])])","pinned":true,"hidden":false,"mode":"ojs"},{"id":309,"value":"md`---`","pinned":false,"hidden":false,"mode":"ojs"},{"id":359,"value":"$30","pinned":false,"hidden":false,"mode":"ojs"},{"id":197,"value":"$31","pinned":false,"hidden":false,"mode":"ojs"},{"id":600,"value":"meshgrid = function(coords, {dtype=coords[0].constructor, flat=false}={}) {\n if(flat) {\n // Construct the flattened result directly with no temporary arrays.\n const dims = coords.map(array => array.length);\n const prods = dims.reduce(\n (prods,dim) => { prods.push(prods[prods.length-1] * dim); return prods; }, [dims.length]);\n return dtype.from(\n {length: prods[prods.length-1]},\n (_,i) => {\n const which_dim = i % dims.length;\n const dim_index = Math.floor(i / prods[which_dim]) % dims[which_dim];\n return coords[which_dim][dim_index];\n }\n );\n }\n else {\n // Construct nested arrays, using dtype for the innermost arrays.\n const nest = function(coords, values) {\n return coords.length ?\n Array.from({length:coords[0].length}, (_,i)=>nest(coords.slice(1), values.concat([coords[0][i]])))\n : dtype.from(values);\n }\n return nest(coords, []);\n }\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":190,"value":"argsort = function(array, {dtype=Int32Array}={}) {\n return astype(dtype, Array.from(array)\n .map((x,i) => [x,i])\n .sort((a,b) => a[0]-b[0])\n .map(([x,i]) => i));\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":585,"value":"argmax = function(array) {\n // From https://stackoverflow.com/questions/11301438/return-index-of-greatest-value-in-an-array/11301464\n return array.reduce((iMax, x, i, arr) => x > arr[iMax] ? i : iMax, 0);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":587,"value":"argmin = function(array) {\n return array.reduce((iMax, x, i, arr) => x < arr[iMax] ? i : iMax, 0);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":19,"value":"diff = function(array, {dtype=array.constructor}={}) {\n return astype(dtype, function*() {\n let last = null;\n for(const value of array) {\n if(last != null) yield value - last;\n last = value;\n }\n }());\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":11,"value":"cumsum = function(array, {dtype=array.constructor}={}) {\n return astype(dtype, function*() {\n let sum = 0;\n for(const value of array) {\n sum += value;\n yield sum;\n }\n }());\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":749,"value":"geomspace = function(start, stop, num, {endpoint=true, dtype=Float64Array}={}) {\n return logspace(Math.log10(start), Math.log10(stop), num, { endpoint, dtype });\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":618,"value":"logspace = function(start, stop, num, {endpoint=true, dtype=Float64Array, base=10}={}) {\n const pow = linspace(start, stop, num, {endpoint:endpoint, dtype:dtype});\n return pow.map(p => base ** p);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":69,"value":"linspace = function(start, stop, num, {endpoint=true, dtype=Float64Array}={}) {\n return astype(dtype, function*() {\n const delta = (stop - start) / (endpoint ? (num - 1) : num);\n for(let i = 0; i < num; i++) {\n yield start + i * delta;\n }\n }());\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":263,"value":"arange = function(stop, {start=0, step=1, dtype=Float64Array}={}) {\n return astype(dtype, function*() {\n let value=start;\n while(value < stop) {\n yield value;\n value += step;\n }\n }());\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":442,"value":"function ones(n, kwargs={}) {\n return full(n, 1, kwargs);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":435,"value":"function zeros(n, kwargs={}) {\n return full(n, 0, kwargs);\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":439,"value":"function full(n, value, {dtype=Float64Array}={}) {\n return astype(dtype, function*() {\n for(let i=0; i < n; i++) yield value;\n }());\n}","pinned":false,"hidden":false,"mode":"ojs"},{"id":50,"value":"astype = function(dtype, g) {\n try {\n return dtype.from(g);\n }\n catch(error) {\n return g;\n }\n}","pinned":false,"hidden":false,"mode":"ojs"}],"files":"$W32","stdlib":"1","titling":"auto"}