2b:null 2c:["$","title",null,{"children":"Numeric Integration (Quadrature) | Lao | Observable"}] 31:T941,viewof settings = { let form = html``; const mod = [1, 1, 1, 1, 2, 3, 4, 2, 3, 4, 10, 1] let cap = 100 let rule, divisions, plusOne form.oninput = () => { rule = Number(form.method.value) if(rule == 4 || rule == 5 || rule == 6){plusOne = 1}else{plusOne = 0} divisions = form.samples.valueAsNumber + (mod[rule] - form.samples.valueAsNumber % mod[rule] + plusOne ) % mod[rule] if(3 <= rule && rule <= 6){ divisions = Math.max(rule-1, divisions)} // for trapazoids form.samples.nextElementSibling.value = ' ' + divisions + ' samples' form.value = [ rule, divisions ] }; form.oninput(); return form; }32:T20e2, graph = { const w = width; const h = 300; const padding = {x0:30, x1:7, y0:20, y1:20}; const color = ['#1EDE89', '#FFAE42',]; // smooth line, quadrature line const rule = settings[0]; ////////////////////////////////// // Functions for graphing lines // ////////////////////////////////// // lagrangian polynomial interpolation function lagrange(pointList){ // returns the coefficienct of the minimal polynomial that passes through n points // Vandermonde Matrix let V = [] for(let i=0; i{ let points = [] // left, center and right rectangle rules if(rule <3){ step = (w-padding.x0-padding.x1)*3 dx = (domain[1]-domain[0]) / settings[1] for(let i=0; i{ let numerator = 0 let denominator = 0 for( let i=0; i{ let points = [] let step = (w-padding.x0-padding.x1)*3 for(let i=0; i xScale(d[0])) .y((d) => yScale(d[1])) // Integral Approximation const intPath = svg.append('path') .datum( fInt() ) .attr('d', line) .attr('fill', color[1]) .attr('stroke', color[1]) .attr('stroke-linejoin','round') .attr("fill-opacity","0.03") .attr("pointer-events", "none"); // if overflow, user can still access UI // Smooth function line const fPath = svg.append('path') .datum( data ) .attr('d', line) .attr('fill', 'none') .attr('stroke', color[0]) .attr('stroke-linejoin','round') .attr('mix-blend-mode', 'multiply'); // sample points const dot = svg.append('g') .selectAll("dot") .data(dotData) .enter() .append("circle") .attr("cx", (d,i) => xScale( d[0] )) .attr("cy", (d,i) => yScale( d[1] )) .attr("r", 2) .style("fill", '#909090'); // x and y axis const xLine = svg .selectAll("curve") .data([{name:'xAxis'}, {name:'yAxis'}]) .enter() .append('path') .datum((d,i) => [ [ [xRange[0],0] , [xRange[1],0] ], [ [0,yRange[0]] , [0,yRange[1]] ] ][i]) .attr('d', line) .style("stroke", "black") .style("stroke-width", .5) // axes numbers let xAxis = d3.axisBottom(xScale).ticks(10); svg.append("g") .attr("transform", `translate(0,${h - padding.y0})`) .call(xAxis) .call(g => g.select(".domain").remove()); //removes line let yAxis = d3.axisLeft(yScale); svg.append("g") .attr("transform", `translate(${padding.x0}, 0)`) .call(yAxis) .call(g => g.select(".domain").remove()); //removes line // text svg.append("text") // graph title .attr("x", padding.x0 + (w-padding.x0-padding.x1)/2) .attr("y", 5 ) .attr("text-anchor", "middle") .style("font-size", "14px") .attr("font-family", "Arial") .attr("font-weight",700) .text("Function Quadrature Plot"); // axes lables svg.append("text") // x axis label .attr("x", padding.x0 + (w-padding.x0-padding.x1)/2 ) .attr("y", h+10 ) .attr("text-anchor", "middle") .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight",700) .text("Input"); svg.append("text") // y axis label .attr("x", 0 ) .attr("y", 5 ) .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight",700) .text("Output"); // print return svg.node(); }33:T1799,error = { const w = width; const h = 350; const padding = {x0:0, x1:40, y0:10, y1:30}; const color = ["#e15759","#9030F0","#e15759","#59a14f","#59a14f","#59a14f","#59a14f","#3030F0","#3030F0","#3030F0","#3030F0","#000000"] let xRange = [1, 100 ] let yRange = [.0000000000002, 100] // linear scales let xScale = d3.scaleLinear(xRange, [padding.x0, w - padding.x1] ); let yScale = d3.scaleLog( yRange, [h - padding.y0, padding.y1] ); // canvas let svg = d3 .select(DOM.svg(w, h)) .style("overflow", "visible"); // for when axis numbers are long let line = d3 .line() .x((d) => xScale( Math.min(d[0], 100) )) .y((d) => yScale(d[1])) // horizontal grid lines let grid = [] for(let i=0; i<15; i++){ grid.push( [ [1, 10**(2-i)], [100, 10**(2-i)] ] ) } const gridPath = svg.selectAll("curve") .data(grid) .enter() .append('path') .attr('stroke', '#EEEEEE') .datum((d,i) => grid[i]) .attr('d', line); // plot function const path = svg.selectAll("curve") .data(percentError) .enter() .append('path') .attr('fill', 'none') .attr('stroke-width', 1) .attr('stroke', (d,i) => color[i]) .attr('stroke-linejoin','round') .attr('stroke-linecap','round') .datum((d,i) => percentError[i]) .attr('d', line); path .filter(function (d, i) { return i === settings[0];}) .attr('stroke-width', 2.5) .raise() // axes numbers var percentFormatter = d3.format("1.00s") let xAxis = d3.axisBottom(xScale).ticks(20); svg.append("g") .attr("transform", `translate(0,${h - padding.y0})`) .call(xAxis) .call(g => g.select(".domain").remove()); //removes line /*let yAxisL = d3.axisLeft(yScale).ticks(13) .tickFormat(function(d) { return percentFormatter(d)+" %"; }) svg.append("g") .attr("transform", `translate(${padding.x0}, 0)`) .call(yAxisL) .call(g => g.select(".domain").remove());*/ //removes line let yAxisR = d3.axisRight(yScale).ticks(13) .tickFormat(function(d) { return percentFormatter(d)+"%"; }) svg.append("g") .attr("transform", `translate(${w - padding.x1}, 0)`) .call(yAxisR) .call(g => g.select(".domain").remove()); //removes line // TEXT // rule labels let findPosition = (pointList) =>{ for(let i=0; i xScale( d[0] ) ) .attr("y", (d,i) => yScale( d[1] )+2 ) .attr("text-anchor", "end") .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight", (d,i) => (i==settings[0]) ? 700 : 300) .text((d,i) => labelData[i]) .style("fill", (d,i) => color[i]) .attr("stroke", "white") .attr("paint-order", "stroke") .attr("stroke-width", 2.5); label .filter(function (d, i) { return i === settings[0];}) .raise() // Label error of current graph const sampleLine = svg.append('line') .style("stroke", 'black') .attr('opacity', .1 ) .attr("x1", xScale(settings[1]) ) .attr("y1", yScale(100)) .attr("x2", xScale(settings[1]) ) .attr("y2", h - padding.y1+20); const point = svg.append('circle') .attr('r', 3) .attr('cx', xScale(settings[1]) ) .attr('cy', yScale( percentError[settings[0]].find( e => e[0] == settings[1])[1] )) .attr('fill', color[settings[0]]) .attr('stroke', 'white') .attr("stroke-width", 2) const currentError = svg.append("text") .attr('x', xScale(settings[1]) ) .attr('y', -6 + yScale( percentError[settings[0]].find( e => e[0] == settings[1])[1] )) .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight",700) .attr("text-anchor", "middle") .attr('fill', color[settings[0]]) .attr("stroke", "white") .attr("paint-order", "stroke") .attr("stroke-width", 4) .attr('stroke-linejoin','round') .text( d3.format(".3s")( percentError[settings[0]].find( e => e[0] == settings[1])[1] )+"%" ); const currentSample = svg.append("text") .attr('x', xScale(settings[1]) ) .attr('y', h - padding.y0 +16) .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight",700) .attr("text-anchor", "middle") .attr('fill', color[settings[0]]) .attr("stroke", "white") .attr("paint-order", "stroke") .attr("stroke-width", 10) .attr('stroke-linejoin','round') .text( settings[1] ) // graph title svg.append("text") .attr("x", 30+padding.x0 + (w-padding.x0-padding.x1)/2) .attr("y", 20 ) .attr("text-anchor", "middle") .style("font-size", "14px") .attr("font-family", "Arial") .attr("font-weight",700) .text("Quadrature Percent Error"); // axes lables svg.append("text") // x axis label .attr("x", padding.x0 + (w-padding.x0-padding.x1)/2 ) .attr("y", h+20 ) .attr("text-anchor", "middle") .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight",700) .text("Number of Sample Points"); svg.append("text") // y axis label .attr("x", w-padding.x1 + 5 ) .attr("y", 15 ) .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight",700) .text("Error"); // print return svg.node(); }34:Ta69,percentError={ let error = [] let percentError = (list, expected) => { error = [] for(let i=0; isingle interval Gaussian Quadrature is almost always the most efficient form of quadrature, because as sample points are added, it can approximate higher derivatives of the sampled function. This is not the case when the interval contains regions of a function with massively different curvature, such as a bell curve. - If the function or derivative is not continuous, such as a jump discontinuity or a cusp, all methods are about as equally bad. Solve this problem by dividing the function into intervals, and place an interval bound on each discontinuity. - n-point Gaussian quadrature is always better than the corresponding Newton-Cotes quadrature because it optimizes where to sample points: 1-point Gaussian (the midpoint rule) is slightly better than the trapezoid rule, 2-point Gaussian is a little better than Simpson's 1/3 rule, 3-point Gaussian is better than Simpson's 3/8 rule, 4-point Gaussian is much better than Boole's rule. - Gaussian quadrature can estimate functions integrated over an open interval because it does not sample the interval bounds. Newton-Cotes can only estimate closed intervals because it does sample the bounds. This makes Gaussian quadrature useful for functions with asymptotes and point discontinuities. - Gauss-Legendre quadrature is the best general purpose kind of Gaussian quadrature, which use Legendre polynomials. [Other kinds][1] of Gaussian quadrature exist which use different polynomial bases, and are more efficient for certain kinds of problems. [1]:https://en.wikipedia.org/wiki/Gaussian_quadrature#Other_forms36:T7b9,The next advancement after a Reimann sum is [Newton-Cotes quadrature][6], which samples multiple points per interval, and calculates the area under the polynomial that passes through those points. This calculates the first n terms of the function's [Taylor's series][7]. To compute, divide a function into intervals. Then for each interval *a* to *b*, sample the function at equally spaced points ${tex`f_0, f_1, ..., f_{n-1}`}, and integrate the minimal polynomial that intersects them. Lower order Newton-Cotes quadrature rules have common names, but the technique can be expanded to any number of samples. |Rule | Interpolation | *Step h* || Formula for each Interval | | :------------ | :------------ | :------: || :------ | | [Trapezoid][2] | Linear | ${tex`\frac{b-a}{2}`} || ${tex`\, \frac{1}{2} \, h (f_0+f_1)`} | | [Simpson's 1/3][3] | Parabolic | ${tex`\frac{b-a}{3}`} || ${tex`\, \frac{1}{3} \, h (f_0+4f_1+f_2)`} | | [Simpson's 3/8][4] | Cubic | ${tex`\frac{b-a}{4}`} || ${tex`\, \frac{3}{8} \, h (f_0+3f_1+3f_2+f_3)`} | | [Boole's][5] | Quartic | ${tex`\frac{b-a}{5}`} || ${tex`\frac{2}{45} h (7f_0+32f_1+12f_2+32f_3+7f_4)`} | Each rule provides exact solutions for polynomials with the less than or equal order of their interpolation. [Newton-Cotes quadrature][6] always samples a point at the beginning and end of the interval. Since it is normally applied as multiple intervals, the last point for the previous interval becomes the first point for the next, and we essentially get a sample point for free. [1]:https://en.wikipedia.org/wiki/Riemann_sum#Methods [2]:https://en.wikipedia.org/wiki/Trapezoidal_rule [3]:https://en.wikipedia.org/wiki/Simpson%27s_rule#Simpson's_1/3_rule [4]:https://en.wikipedia.org/wiki/Simpson%27s_rule#Simpson's_3/8_rule [5]:https://en.wikipedia.org/wiki/Boole%27s_rule [6]:https://mathworld.wolfram.com/Newton-CotesFormulas.html [7]:https://en.wikipedia.org/wiki/Taylor_series37:T7d3,Given a set of points with unique ${tex`x`} coordinates, > ${tex`(x_0,y_0), \space (x_1,y_1), \space (x_2,y_2), \space \dots, \space (x_n,y_n)`} a minimal polynomial can be found that passes through each point. >${tex`P(x) = a_0+a_1 x + a_2 x^2 + ... + a_n x^n`} There are various methods to calculate these coefficients. A [Vandermonde matrix][2] can calculate the coefficients of the polynomial, but due to the exponential rounding error, it only works for polynomials up to about order 24 with JavaScript: > ${tex` \begin{bmatrix} a_0 \\ a_1 \\ a_2 \\ \vdots \\ a_n \end{bmatrix} = \begin{bmatrix} 1 & x_0 & x_0^2 & \dots & x_0^n \\ 1 & x_1 & x_1^2 & \dots & x_1^n \\ 1 & x_2 & x_2^2 & \dots & x_2^n \\ \vdots & \vdots & \vdots & \ddots & \vdots \\ 1 & x_n & x_n^2 & \dots & x_n^n \\ \end{bmatrix} ^{-1} \begin{bmatrix} y_0 \\ y_1 \\ y_2 \\ \vdots \\ y_n \end{bmatrix} `} [Jacob Rus](https://observablehq.com/@jrus) was kind enough to comment and let me know of the [barycentric form of the Lagrange polynomial](https://en.wikipedia.org/wiki/Lagrange_polynomial#Barycentric_form), which is a numerically stable and fast way of calculating the interpolating polynomial. From a list of points with ${tex`x`} and ${tex`y`} coordinates: > ${tex`\vec{p} = (x_1,y_1) \oplus (x_2,y_2) \oplus ... \oplus (x_n,y_n) = \begin{bmatrix} x_1 & y_1 \\ x_2 & y_2 \\ \vdots & \vdots \\ x_n & y_n \end{bmatrix}`} Next, weights ${tex`w_j`} are calculated for each jth point by multiplying the difference between the jth ${tex`x`} coordinate and all other kth ${tex`x`} coordinates. > ${tex`w_j = \dfrac{1}{\displaystyle\prod_{\substack{k \neq j}}^{n} (x_j - x_k)}`} Then the second true form of the barycentric interpolating polynomial ${tex`L(x)`} is: > ${tex`L(x) = \dfrac{\displaystyle\sum_{j=1}^{n} \dfrac{w_j y_j}{x - x_j}}{\displaystyle\sum_{j=1}^{n} \dfrac{w_j}{x - x_j}}`} [1]:https://mathworld.wolfram.com/LagrangeInterpolatingPolynomial.html [2]:https://en.wikipedia.org/wiki/Vandermonde_matrix 38:T479,viewof spacing = { let form = html``; form.oninput = () => { form.value = [ form.samples.valueAsNumber, form.spacing.valueAsNumber ] }; form.oninput(); return form; }39:Te50,runge = { const w = width; const h = 350; const padding = {x0:30, x1:7, y0:10, y1:20}; const color = ['#000000', '#ff0000',]; // smooth line, quadrature line const n = spacing[0] const s = spacing[1] let interval = [-1,1] let equal = [] for(let i=0; i{ let points = [] dx = interval[1]-interval[0] pointList = [] for(let i=0; i{ let numerator = 0 let denominator = 0 for( let i=0; i{ let points = [] let step = (w-padding.x0-padding.x1)*3 for(let i=0; i xScale(d[0])) .y((d) => yScale(d[1])) // Integral Approximation const intPath = svg.append('path') .datum( fInt() ) .attr('d', line) .attr('fill', color[1]) .attr('stroke', color[1]) .attr('stroke-linejoin','round') .attr("fill-opacity","0.03") .attr("pointer-events", "none"); // if overflow, user can still access UI // Smooth function line const fPath = svg.append('path') .datum( data ) .attr('d', line) .attr('fill', 'none') .attr('stroke', color[0]) .attr('stroke-width', 2) .attr('stroke-linejoin','round') .attr('mix-blend-mode', 'multiply'); // sample points const dot = svg.append('g') .selectAll("dot") .data(dotData) .enter() .append("circle") .attr("cx", (d,i) => xScale( d[0] )) .attr("cy", (d,i) => yScale( d[1] )) .attr("r", 4) .style("fill", '#909090') .style("stroke", 'white'); // print return svg.node(); }3a:T1397,constantEquations = { const padding = {left:30, right:0, top:30, bottom:5} const w = Math.min(625, width) const h = w/3 - padding.left - padding.right + padding.top + padding.bottom const wCell = Math.round(w/3 - padding.left - padding.right) const step = 0 const color = ['#1EDE89', '#FFAE42',] // smooth line, quadrature line // scale let xScale = d3.scaleLinear([ -1.5, 1.5 ], [padding.left, w/3-padding.right]); let yScale = d3.scaleLinear([ -1.5, 1.5 ], [h-padding.bottom , padding.top]); let c0 = 1 let f = (x) => { return c0 } let approxData let approxPlot = () => { approxData = [] for( let i=0; i<3; i++){ approxData.push( [] ) approxData[i].push( [-1,0] ) approxData[i].push( [-1,c0] ) approxData[i].push( [1,c0] ) approxData[i].push( [1,0] ) } } let x0, y0, a0, x1, y1, a1, arrowL, arrowR let arrow = (lines) => { for(let i=0; i xScale(d[0])) .y((d) => yScale(d[1])) // canvas let svg = d3 .select(DOM.svg(w, h)) const approxLine = svg.selectAll("g") .data(approxData) .enter() .append('path') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('fill', 'none') .attr('stroke', color[1]) .attr('fill', color[1]) .attr("fill-opacity","0.03") .attr('d', (d) => line(d) ); const fLine = svg.selectAll("g") .data(lineData) .enter() .append('path') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('fill', 'none') .attr('stroke', color[0]) .attr('stroke-linejoin','round') .attr('d', (d) => line(d) ); const points = svg.selectAll("g") .data(pointData) .enter() .append('circle') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('cx', d => xScale( d[0] ) ) .attr('cy', d => yScale( d[1] ) ) .attr('r', 3) .attr('fill', 'grey') .attr('stroke', 'white' ) .attr('stroke-linejoin','round') .attr('d', (d) => line(d) ); const text = svg.selectAll("label") .data(textData) .enter() .append("text") .text(d => d.text) .attr("x", d => d.x) .attr("y", d => d.y ) .attr("text-anchor", "middle") .style("font-size", "14px") .attr("font-family", "Arial") .attr("font-weight",200) .attr('fill', 'black') //axes let xAxis1 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${0},${yScale(0)})`) .call(xAxis1) let xAxis2 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${w/3},${yScale(0)})`) .call(xAxis2) let xAxis3 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${2*w/3},${yScale(0)})`) .call(xAxis3) let yAxis = d3.axisLeft(yScale).ticks(5); svg.append("g") .attr("transform", `translate(${xScale(-1.5)}, 0)`) .call(yAxis) .call(g => g.select(".domain").remove()) // print let rand while(true){ rand = Math.random()*2-1 if(0 <= rand){ c0 = 1.5 * Math.sqrt( Math.abs( rand) ) } else { c0 =-1.5 * Math.sqrt( Math.abs( rand) ) } approxPlot() approxLine .data(approxData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) lineData = [ [[-1.5,c0],[1.5,c0]], [[-1.5,c0],[1.5,c0]], [[-1.5,c0],[1.5,c0]] ] arrow( lineData ) fLine .data(lineData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) pointData = [ [-1, c0], [ 0, c0], [ 1, c0] ] points .data(pointData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('cx', d => xScale( d[0] ) ) .attr('cy', d => yScale( d[1] ) ) yield svg.node(); await Promises.delay(4000) } }3b:T1403,linearEquations = { const padding = {left:30, right:0, top:30, bottom:5} const w = Math.min(625, width) const h = w/3 - padding.left - padding.right + padding.top + padding.bottom const wCell = Math.round(w/3 - padding.left - padding.right) const step = 0 const color = ['#1EDE89', '#FFAE42',] // smooth line, quadrature line // scale let xScale = d3.scaleLinear([ -1.5, 1.5 ], [padding.left, w/3-padding.right]); let yScale = d3.scaleLinear([ -1.5, 1.5 ], [h-padding.bottom , padding.top]); let c0 = 1 let c1 = 1 let approxData let approxPlot = () => { approxData = [] for( let i=0; i<3; i++){ approxData.push( [] ) approxData[i].push( [-1,0] ) approxData[i].push( [-1,c0 + (i-1)*c1] ) approxData[i].push( [1,c0 + (i-1)*c1] ) approxData[i].push( [1,0] ) } } let x0, y0, a0, x1, y1, a1, arrowL, arrowR let arrow = (lines) => { for(let i=0; i xScale(d[0])) .y((d) => yScale(d[1])) // canvas let svg = d3 .select(DOM.svg(w, h)) .style("overflow", "visible") const approxLine = svg.selectAll("g") .data(approxData) .enter() .append('path') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('fill', 'none') .attr('stroke', color[1]) .attr('fill', color[1]) .attr("fill-opacity","0.03") .attr('d', (d) => line(d) ); const fLine = svg.selectAll("g") .data(lineData) .enter() .append('path') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('fill', 'none') .attr('stroke', color[0]) .attr('stroke-linejoin','round') .attr('d', (d) => line(d) ); const points = svg.selectAll("g") .data(pointData) .enter() .append('circle') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('cx', d => xScale( d[0] ) ) .attr('cy', d => yScale( d[1] ) ) .attr('r', 3) .attr('fill', 'grey') .attr('stroke', 'white' ) .attr('d', (d) => line(d) ); const text = svg.selectAll("label") .data(textData) .enter() .append("text") .text(d => d.text) .attr("x", d => d.x) .attr("y", d => d.y ) .attr("text-anchor", "middle") .style("font-size", "14px") .attr("font-family", "Arial") .attr("font-weight",200) .attr('fill', 'black') //axes let xAxis1 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${0},${yScale(0)})`) .call(xAxis1) let xAxis2 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${w/3},${yScale(0)})`) .call(xAxis2) let xAxis3 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${2*w/3},${yScale(0)})`) .call(xAxis3) let yAxis = d3.axisLeft(yScale).ticks(5); svg.append("g") .attr("transform", `translate(${xScale(-1.5)}, 0)`) .call(yAxis) .call(g => g.select(".domain").remove()) // print let rand while(true){ rand = Math.random()*2-1 if(0 <= rand){ c0 = Math.sqrt( Math.abs( rand) ) } else { c0 = -Math.sqrt( Math.abs( rand) ) } c1 = Math.random()*2-1 approxPlot() approxLine .data(approxData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) lineData = [ [[-1.5,c0-1.5*c1],[1.5,c0+1.5*c1]], [[-1.5,c0-1.5*c1],[1.5,c0+1.5*c1]], [[-1.5,c0-1.5*c1],[1.5,c0+1.5*c1]] ] arrow( lineData ) fLine .data(lineData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) pointData = [ [-1, c0-c1], [ 0, c0], [ 1, c0+c1] ] points .data(pointData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('cx', d => xScale( d[0] ) ) .attr('cy', d => yScale( d[1] ) ) yield svg.node(); await Promises.delay(4000) } }3c:T1282,linearDecomposition = { const padding = {left:30, right:0, top:30, bottom:5} const w = Math.min(625, width) const h = w/3 - padding.left - padding.right + padding.top + padding.bottom const wCell = Math.round(w/3 - padding.left - padding.right) const step = 0 const color = ['#1EDE89', '#FFAE42',] // smooth line, quadrature line // scale let xScale = d3.scaleLinear([ -1.5, 1.5 ], [padding.left, w/3-padding.right]); let yScale = d3.scaleLinear([ -1.5, 1.5 ], [h-padding.bottom , padding.top]); let c0 = 1 let c1 = 1 let approxData let approxPlot = () => { approxData = [] approxData.push( [] ) approxData[0].push( [-1,0] ) approxData[0].push( [-1,c0 - c1] ) approxData[0].push( [1,c0 + c1] ) approxData[0].push( [1,0] ) approxData.push( [] ) approxData[1].push( [-1,0] ) approxData[1].push( [-1,c0 ] ) approxData[1].push( [1,c0 ] ) approxData[1].push( [1,0] ) approxData.push( [] ) approxData[2].push( [-1,0] ) approxData[2].push( [-1,-c1] ) approxData[2].push( [1, c1] ) approxData[2].push( [1,0] ) } let x0, y0, a0, x1, y1, a1, arrowL, arrowR let arrow = (lines) => { for(let i=0; i xScale(d[0])) .y((d) => yScale(d[1])) // canvas let svg = d3 .select(DOM.svg(w, h)) .style("overflow", "visible") const approxLine = svg.selectAll("g") .data(approxData) .enter() .append('path') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('fill', 'none') .attr('stroke', color[1]) .attr('fill', color[1]) .attr("fill-opacity","0.03") .attr('d', (d) => line(d) ); const fLine = svg.selectAll("g") .data(lineData) .enter() .append('path') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('fill', 'none') .attr('stroke', color[0]) .attr('stroke-linejoin','round') .attr('d', (d) => line(d) ); const text = svg.selectAll("label") .data(textData) .enter() .append("text") .text(d => d.text) .attr("x", d => d.x) .attr("y", d => d.y ) .attr("text-anchor", "middle") .style("font-size", "14px") .attr("font-family", "Arial") .attr("font-weight",200) .attr('fill', 'black') //axes let xAxis1 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${0},${yScale(0)})`) .call(xAxis1) let xAxis2 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${w/3},${yScale(0)})`) .call(xAxis2) let xAxis3 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${2*w/3},${yScale(0)})`) .call(xAxis3) let yAxis = d3.axisLeft(yScale).ticks(5); svg.append("g") .attr("transform", `translate(${xScale(-1.5)}, 0)`) .call(yAxis) .call(g => g.select(".domain").remove()) // print let rand while(true){ rand = Math.random()*2-1 if(0 <= rand){ c0 = Math.sqrt( Math.abs( rand) ) } else { c0 = -Math.sqrt( Math.abs( rand) ) } c1 = Math.random()*2-1 approxPlot() approxLine .data(approxData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) lineData = [ [[-1.5,c0-1.5*c1],[1.5,c0+1.5*c1]], [[-1.5,c0],[1.5,c0]], [[-1.5,-1.5*c1],[1.5,1.5*c1]] ] arrow( lineData ) fLine .data(lineData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) yield svg.node(); await Promises.delay(4000) } }3d:T11ac,linearOverlay = { const padding = {left:30, right:0, top:30, bottom:5} const w = Math.min(625, width) const h = w/3 - padding.left - padding.right + padding.top + padding.bottom const wCell = Math.round(w/3 - padding.left - padding.right) const step = 0 const color = ['#1EDE89', '#FFAE42',] // smooth line, quadrature line // scale let xScale = d3.scaleLinear([ -1.5, 1.5 ], [padding.left, w/3-padding.right]); let yScale = d3.scaleLinear([ -1.5, 1.5 ], [h-padding.bottom , padding.top]); let c0 = 1 let c1 = 1 let approxData let approxPlot = () => { approxData = [] approxData.push( [] ) approxData[0].push( [-1,0] ) approxData[0].push( [-1,c0 - c1] ) approxData[0].push( [1,c0 + c1] ) approxData[0].push( [1,0] ) approxData.push( [] ) approxData[1].push( [-1,0] ) approxData[1].push( [-1,c0 ] ) approxData[1].push( [1,c0 ] ) approxData[1].push( [1,0] ) } let x0, y0, a0, x1, y1, a1, arrowL, arrowR let arrow = (lines) => { for(let i=0; i xScale(d[0])) .y((d) => yScale(d[1])) // canvas let svg = d3 .select(DOM.svg(w, h)) .style("overflow", "visible") const approxLine = svg.selectAll("g") .data(approxData) .enter() .append('path') .attr('fill', 'none') .attr('stroke', color[1]) .attr('fill', color[1]) .attr("fill-opacity","0.03") .attr('d', (d) => line(d) ); const fLine = svg.selectAll("g") .data(lineData) .enter() .append('path') .attr('fill', 'none') .attr('stroke', color[0]) .attr('stroke-linejoin','round') .attr('d', (d) => line(d) ); const points = svg.selectAll("g") .data(pointData) .enter() .append('circle') .attr("transform", (d,i) => "translate(" + i * w/3 + "," + 0 + ")") .attr('cx', d => xScale( d[0] ) ) .attr('cy', d => yScale( d[1] ) ) .attr('r', 3) .attr('fill', 'grey') .attr('stroke', 'white' ) .attr('d', (d) => line(d) ); const text = svg.selectAll("label") .data(textData) .enter() .append("text") .text(d => d.text) .attr("x", d => d.x) .attr("y", d => d.y ) .attr("text-anchor", "middle") .style("font-size", "14px") .attr("font-family", "Arial") .attr("font-weight",200) .attr('fill', 'black') //axes let xAxis1 = d3.axisBottom(xScale).ticks(3); svg.append("g") .attr("transform", `translate(${0},${yScale(0)})`) .call(xAxis1) let yAxis = d3.axisLeft(yScale).ticks(5); svg.append("g") .attr("transform", `translate(${xScale(-1.5)}, 0)`) .call(yAxis) .call(g => g.select(".domain").remove()) // print let rand while(true){ rand = Math.random()*2-1 if(0 <= rand){ c0 = Math.sqrt( Math.abs( rand) ) } else { c0 = -Math.sqrt( Math.abs( rand) ) } c1 = Math.random()*2-1 approxPlot() approxLine .data(approxData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) lineData = [ [[-1.5,c0-1.5*c1],[1.5,c0+1.5*c1]], [[-1.5,c0],[1.5,c0]] ] arrow( lineData ) fLine .data(lineData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('d', (d) => line(d) ) pointData = [ [ 0, c0] ] points .data(pointData) .transition().duration(2000).ease(d3.easeQuadInOut) .attr('cx', d => xScale( d[0] ) ) .attr('cy', d => yScale( d[1] ) ) yield svg.node(); await Promises.delay(4000) } }3e:Te40,Since we are using an interval centered on the origin, not only do linear terms cancel, but all terms that have only odd powers of ${tex`x`} reduce to ${tex`0`}. This means for every 1 carefully placed sample point, Gaussian quadrature can estimate 2 antiderivatives of the function. [Polynomials](https://en.wikipedia.org/wiki/Polynomial) are constants ${tex`a_i`} times integer powers of x: > ${tex` y = a_0 + a_1 x + a_2 x^2 + ... + a_n x^n`} Polynomial spaces are vector spaces. The [standard basis](https://en.wikipedia.org/wiki/Standard_basis) of a [polynomial vector space](https://en.wikipedia.org/wiki/Monomial_basis) are integer powers of ${tex`x`}: > ${tex` \mathbb{P}_n = (1, x, x^2, x^3, ..., x^n)`} Any Basis that spans the same space are isomorphic. We can choose different polynomials that are more useful for finding the weight and position of each node. Using the [Gram–Schmidt orthogonalization process](https://en.wikipedia.org/wiki/Gram%E2%80%93Schmidt_process), the standard polynomial basis can be transformed into the [Legendre polynomial basis](https://en.wikipedia.org/wiki/Legendre_polynomials#Rodrigues'_formula_and_other_explicit_formulas). The first eight Legendre polynomials are: | Even Legendre Polynomials | Odd Legendre Polynomials | | ----------- | ----------- | | ${tex` L_0 = 1 `} | ${tex` L_1 = x `} | | ${tex` L_2 = \frac{1}{2}(3x^2-1) `} | ${tex` L_3 = \frac{1}{2}(5x^3 - 3x) `} | | ${tex` L_4 = \frac{1}{8}(35x^4-30x^2+3) `} | ${tex` L_5 = \frac{1}{8}(63x^5-70x^3+15x) `} | | ${tex` L_6 = \frac{1}{16}(231x^6-315x^4+105x^2-5 `} | ${tex` L_7 = \frac{1}{16}(429x^7-693x^5+315x^3-35x) `} | Just as before, we can define a polynomial vector space using coeffecients ${tex`b_i`} and Legendre polynomials ${tex`L_i`} > ${tex` y = b_0 L_0 + b_1 L_1 + b_2 L_2 + ... + b_n L_n`}
> ${tex` \mathbb{P}_n = (L_0, L_1, L_2, ..., L_n)`} The Legendre polynomials have a few useful properties. First, all odd Legendre polynomials integrate to 0 over the ${tex`[-1, 1]`} interval. Second, Legendre polynomials have all zeros in the ${tex`[-1, 1]`} interval. We can [divide](https://en.wikipedia.org/wiki/Polynomial_long_division) ${tex` P(x)`}, a polynomial of order 2n-1, by an nth degree Legendre polynomial ${tex`L_n(x)`}, to get the quotient ${tex` q(x)`} with remainder ${tex` r(x)`}: > ${tex` \dfrac{P(x)}{L_n(x)} = q(x)`} with remainder ${tex`r(x)`} Putting this back together, ${tex` P(x)`} can be written as the product of the quotient ${tex` q(x)`} with Legendre polynomial ${tex`L_n(x)`} plus the remainder ${tex` r(x)`}: > ${tex` P(x) = L_n(x) \cdot q(x) + r(x)`} Since Legendre polynomials have all zeros within the intervals ${tex`[-1,1]`}, if we choose those zeros to be our sample points, the first part of the equation is eliminated, and the number of sample points match ${tex` r(x)`} number of coefficients, which can calculated with polynomial interpolation at those points: > let ${tex` L_n(x) = 0`}
> ${tex` P(x) = 0 \cdot q(x) + r(x)`}
> ${tex` P(x) = r(x)`} This is the higher order version of choosing the middle rectangle rule to exactly approximate both constant and linear equations. Thanks to the [inner product space](https://en.wikipedia.org/wiki/Inner_product_space), Gaussian quadrature solves two polynomials: one polynomial carefully chooses the position of ${tex`n`} sample points, and the second uses polynomial interpolation to find the area under the minimal polynomial through those ${tex`n`} sample points! In addition, the weights are numerically stable, and the samples concentrate on the edges of the interval, minimizing Rudge's phenomena.3f:Teac,Nodes = { const w = Math.min(width, 700); const h = 700; const padding = {x0:15, x1:5, y0:70, y1:0}; let svg = d3 .select(DOM.svg(w, h)) .style("overflow", "visible"); // for when axis numbers are long let xScale = d3.scaleLinear([ -1, 1 ], [padding.x0, w - padding.x1]); let yScale = d3.scaleLinear([ 38, 1 ], [h - padding.y1, padding.y0]); // horizontal lines let line = d3 .line() .x((d) => xScale( Math.min(d[0], 100) )) .y((d) => yScale(d[1])) // horizontal lines const path = svg.selectAll("curve") .data( d3.range(25) ) .enter() .append('path') .attr('fill', 'none') .attr('stroke', 'black') .attr("stroke-width", .5) .datum((d,i) => { if( i<16 ){ return [[-1, i+1], [1,i+1]] } else{ return [[-1, 2*(i-20)+28], [1, 2*(i-20)+28]] } }) .attr('d', line) // create a tooltip var Tooltip = d3.select("#div_template") .append("div") .style("opacity", 0) .attr("class", "tooltip") .style("background-color", "white") .style("border", "solid") .style("border-width", "2px") .style("border-radius", "5px") .style("padding", "5px") // Three function that change the tooltip when user hover / move / leave a cell var mouseover = function(d) { Tooltip .style("opacity", 1) d3.select(this) .style("stroke", "black") .style("opacity", 1); } var mousemove = function(d) { Tooltip .html("The exact value of
this cell is: " + 2) .style("left", (d3.mouse(this)[0]+70) + "px") .style("top", (d3.mouse(this)[1]) + "px") } var mouseleave = function(d) { Tooltip .style("opacity", 0) d3.select(this) .style("stroke", "none") .style("opacity", 0.8) } let nodeData = [] for(let i=1; i<17; i++){ for(let j=0; j xScale(d.cx) ) .attr("cy", d => yScale(d.cy) ) .attr("r", d => d.r) .attr("fill", d => d.fill ) .style("opacity", 0.8) .style("stroke", "none") .style("stroke-width", 8) .attr("paint-order", "stroke") .on("mouseover", mouseover) .on("mousemove", mousemove) .on("mouseleave", mouseleave) let yData = [] for( let i=1; i<17; i++){ yData.push( {text:i, y:yScale(i)+4, x:padding.x0-7} )} yData.push( {text:'...' , y:yScale(18), x:padding.x0-7} ) for( let i=0; i<9; i++){ yData.push( {text:20+10*i, y:yScale(20+2*i)+4, x:padding.x0-7} )} const yAxis = svg.append('g') .selectAll("label") .data(yData) .enter() .append("text") .attr("x", d => d.x ) .attr("y", d => d.y ) .attr("text-anchor", "end") .style("font-size", "10px") .attr("font-family", "Arial") .attr("font-weight",200) .text(d => d.text) // axes let xAxis1 = d3.axisTop(xScale).ticks(11); svg.append("g").attr("transform", `translate(0,${padding.y0-30})`).call(xAxis1) .call(g => g.select(".domain").remove()); //removes line let xAxis2 = d3.axisBottom(xScale).ticks(11); svg.append("g").attr("transform", `translate(0,${h - padding.y1-10})`).call(xAxis2) .call(g => g.select(".domain").remove()); //removes line return svg.node(); }40:T2740,M = ({ add: function add(){ let arg = arguments let size = [] for(let h=0; h0){ nicest = score.indexOf(d3.max(score)) this.rowSwap(A,pivots+1, nicest+1) if((pivots+1) != (nicest+1)){det *= -1} // invert determinant because of row opperation det *= A[pivots][j] // scale determinant by the number a row is multiplied by this.rowScale(A, 1 / A[pivots][j], pivots+1) // normalizes pivot to 1 for(let i=pivots+1; i0){ nicest = score.indexOf(d3.max(score)) // index of first value that is the nicest of column this.rowSwap(I,pivots+1, nicest+1) // move that row to next pivot position this.rowSwap(A,pivots+1, nicest+1) this.rowScale(I, 1 / A[pivots][j], pivots+1) // normalizes pivot to 1 this.rowScale(A, 1 / A[pivots][j], pivots+1) for(let i=0; i1){ for(let i=1; i 0 ){rank+=1} } return rank } , rowAdd: function(A, c, y, x){ // adds c * row y to row x x -=1; y -=1; for(let i=0; i< A[0].length; i++){ A[x][i] += c*A[y][i] if(A[x][i] < .0000001 && A[x][i] > -.0000001){A[x][i]=0} } return A } , rowScale: function(A,c,x){ x -=1; for(let i=0; i< A[0].length; i++){ A[x][i] *= c } return A } , rowSwap: function(A,x,y){ // swaps row x with row y x -=1; y -=1; [A[x], A[y]] = [A[y], A[x]]; return A; } , rowVector: function(A,x){ let row = [] for(let j=0; j0){ nicest = score.indexOf(d3.max(score)) // index of first value that is the nicest of column this.rowSwap(A,pivots+1, nicest+1) // move that row to next pivot position this.rowScale(A, 1 / A[pivots][j], pivots+1) // normalizes pivot to 1 for(let i=pivots+1; i { \n return Math.exp(-10 * (x+.5)**2) + Math.sin(15.7*x)/10 // bell with sine wave\n //return 1 / ( 1+Math.abs(10 * x) ) // cusp with oscilating error\n //return Math.exp(-50 * x**2) // Riemann sum is better than Gaussian\n //return Math.sin(Math.exp(4*x)) // Only single Gaussian can approximate accurately\n //return 1/(1+100*x**2) //Runge Function\n //return 1-Math.abs(x) //absolute value\n // return Math.abs(x)<.5 ? 1 : 0 // step function\n //return Math.exp(-20*(x+0.5)**2) + Math.exp(-20*(x-0.5)**2) //bimodal\n //return 1/(1+Math.exp(-10*x+5))\n \n}","pinned":true,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":42,"value":"domain = [-1,1]","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":288,"value":"$31","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":59,"value":"$32","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":1138,"value":"$33","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3257,"value":"Please note that the convergence continues past the 1 picopercent error mathematically, but due to the limits of number precision in JavaScript, that is the only level that can be reliably achieved.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1589,"value":"// computes 50 intervals, each a 50-point gaussian quadrature\nexpectedValue = {\n let n = 100 // number of intervals\n let h = (domain[1]-domain[0]) / n // step of each interval\n let a, b // bounds of interval\n let sum = 0\n let total = 0\n for(let i=0; i { \n return 1 / (1+25*x**2) // runge's original function\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":656,"value":"md` ## Gaussian Quadrature`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":2720,"value":"Runge's phenomena demonstrates that some ways of distributing sample points are more accurate than others. So what are the best positions?\n\nTo begin, let's start at the simplest case and consider the best position to place a single sample point, which is the rectangle rule. If we are trying to estimate a constant function ${tex`y = a_0`}, any position will produce a rectangle with the exact area. Since gaussian intervals are over the range ${tex`[-1, 1]`} , all these examples will be too.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":3555,"value":"$3a","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3709,"value":"Moving to the next term in the Taylor series, we can consider the same question, but for a linear function ${tex`y = a_0 + a_1 x`}. You can see that the left and right rectangle rule will always over or under estimate a linear equation with a non-zero slope, but the middle rectangle rule still is exact, because error to the left of the point cancels out the error to the right.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":3714,"value":"$3b","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3727,"value":"Why is this happening? The addition property of integrals means that the integral of a sum of terms is the same as integrating each terms separately, and then summing together. Using this, the linear equation can be broken into two integrals:\n\n> ${tex` \\displaystyle\\int_{-1}^1 (a_0 + a_1 x) \\cdot dx = \\displaystyle\\int_{-1}^1 a_0 \\cdot dx + \\displaystyle\\int_{-1}^1 a_1 x \\cdot dx`}\n\nSolving for this equation, the linear ${tex`a_1`} term reduces to ${tex`0`}, and all that is left is the constant ${tex`a_0`} term:\n\n> ${tex` \\displaystyle\\int_{-1}^1 a_0 \\cdot dx + \\displaystyle\\int_{-1}^1 a_1 x \\cdot dx = \\bigg[ a_0 \\cdot x \\bigg]_{-1}^1 + \\bigg[ \\dfrac{a_1 \\cdot x^2}{2} \\bigg]_{-1}^1`}

\n> ${tex`=a_0(1) - a_0(-1) + \\dfrac{a_1 \\cdot 1}{2} - \\dfrac{a_1 \\cdot 1}{2} = 2 \\cdot a_0 `}\n\nThis can also be seen visually:","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":3769,"value":"$3c","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3782,"value":"For the linear term, the area of the two triangles cancel each other out, so the only important information is the constant term. The trick is where to sample the whole equation so only the constant term is measured. In this case, if you overlay the whole equation over the constant term, you can see they always intersect in the middle. Sampling a linear function here always measures the constant term of the linear equation.","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":3788,"value":"$3d","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3804,"value":"$3e","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":2875,"value":"md` **Nodes and Weights** `","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3440,"value":"The `gauss` array contains the nodes and weights for up to 100-point Gaussian quadrature generated from [Keisan's online calculator](https://keisan.casio.com/exec/system/1330940731):","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":1500,"value":"//nodes and weights for 1 to 100 point Legendre Gaussian Quadrature\ngauss = FileAttachment(\"gaussNodesWeightsTo100@1.json\").json()","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":3449,"value":"This array is in the structure of:\n\n> `gauss[ sample number ][ node index ][ =0 for position and =1 for weight ]`\n\nThe **position** of the **27th** node of **50**-point Gaussian quadrature would be accessed as:\n\n> `gauss[ 50 ][ 27 ][ 0 ]`\n\nThis graph summarize the first 100 gaussian nodes. The area of each node is proportional to its weight. Notice that the points are the zeros of the ${tex`n^{th}`} degree Legendre polynomial. ","pinned":false,"hidden":false,"mode":"md","author":"$undefined","summary":"$undefined"},{"id":2878,"value":"$3f","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":2555,"value":"md` ## Math Senpais`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":2559,"value":"md` Enternal gratitude toward these wonderful teachers who put their lectures on YouTube. I could not have understood such a complex topic without their help.\n\nThe insane power of Gaussian Quadrature:
\nhttps://www.youtube.com/watch?v=k-yUdqRXijo\n\nSecond semester linear algebra unit about how exactly Gaussian quadrature works:
\nhttps://www.youtube.com/watch?v=65zwMgGZnUs
\nhttps://www.youtube.com/watch?v=nQZYBWB6q_k
\nhttps://www.youtube.com/watch?v=cKKrGr93f6c
\n\nA CompSci overview of various Quadrature methods:
\nhttps://www.youtube.com/watch?v=uxQCjeo955o\n`","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":2267,"value":"md` **Libraries** `","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":768,"value":"$40","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"},{"id":138,"value":"cephes = {\n const c = await require(\"https://bundle.run/cephes@1.2.0\");\n await c.compiled;\n return c;\n}","pinned":false,"hidden":false,"mode":"ojs","author":"$undefined","summary":"$undefined"}],"files":"$W41","stdlib":"1","titling":"auto"}} 30:"$2f:body"