update work flow

CwJ/alternatives/plotly_plotting.jmd

@@ -1,5 +1,10 @@
 # JavaScript based plotting libraries
 
+!!! alert "Not working with quarto"
+    Currently, the plots generated here are not rendering within quarto.
+
+
+
 This section uses this add-on package:
 
 ```julia

CwJ/derivatives/mean_value_theorem.jmd

@@ -396,7 +396,39 @@ That is the function $f(x)$, minus the secant line between $(a,f(a))$ and $(b, f
 nothing
 ```
 
-An interactive example can be found at [jsxgraph](http://jsxgraph.uni-bayreuth.de/wiki/index.php?title=Mean_Value_Theorem).
+```=html
+<div id="jsxgraph" style="width: 500px; height: 500px;"></div>
+```
+
+```ojs
+//| echo: false
+//| output: false
+
+JXG = require("jsxgraph");
+
+board = JXG.JSXGraph.initBoard('jsxgraph', {boundingbox: [-5, 10, 7, -6], axis:true});
+p = [
+  board.create('point', [-1,-2], {size:2}),
+  board.create('point', [6,5], {size:2}),
+  board.create('point', [-0.5,1], {size:2}),
+  board.create('point', [3,3], {size:2})
+];
+f = JXG.Math.Numerics.lagrangePolynomial(p);
+graph = board.create('functiongraph', [f,-10, 10]);
+
+g = function(x) {
+     return JXG.Math.Numerics.D(f)(x)-(p[1].Y()-p[0].Y())/(p[1].X()-p[0].X());
+};
+
+r = board.create('glider', [
+                    function() { return JXG.Math.Numerics.root(g,(p[0].X()+p[1].X())*0.5); },
+                    function() { return f(JXG.Math.Numerics.root(g,(p[0].X()+p[1].X())*0.5)); },
+                    graph], {name:' ',size:4,fixed:true});
+board.create('tangent', [r], {strokeColor:'#ff0000'});
+line = board.create('line',[p[0],p[1]],{strokeColor:'#ff0000',dash:1});
+```
+
+This interactive example can also be found at [jsxgraph](http://jsxgraph.uni-bayreuth.de/wiki/index.php?title=Mean_Value_Theorem). It shows a cubic polynomial fit to the ``4`` adjustable points labeled A through D. The secant line is drawn between points A and B with a dashed line. A tangent line -- with the same slope as the secant line -- is identified at a point ``(\alpha, f(\alpha))`` where ``\alpha`` is between the points A and B. That this can always be done is a conseuqence of the mean value theorem.
 
 
 ##### Example

CwJ/derivatives/newtons_method.jmd

@@ -285,6 +285,96 @@ gif(anim, imgfile, fps = 1)
 ImageFile(imgfile, caption)
 ```
 
+----
+
+This interactive graphic (built using [JSXGraph](https://jsxgraph.uni-bayreuth.de/wp/index.html)) allows the adjustment of the point `x0`, initially at ``0.85``. Five iterations of Newton's method are illustrated. Different positions of `x0` clearly converge, others will not.
+
+```=html
+<div id="jsxgraph" style="width: 500px; height: 500px;"></div>
+```
+
+```ojs
+//| echo: false
+//| output: false
+
+JXG = require("jsxgraph");
+
+// newton's method
+
+b = JXG.JSXGraph.initBoard('jsxgraph', {
+    boundingbox: [-3,5,3,-5], axis:true
+});
+
+
+f = function(x) {return x*x*x*x*x - x - 1};
+fp = function(x) { return 4*x*x*x*x - 1};
+x0 = 0.85;
+
+nm = function(x) { return x - f(x)/fp(x);};
+
+l = b.create('point', [-1.5,0], {name:'', size:0});
+r = b.create('point', [1.5,0], {name:'', size:0});
+xaxis = b.create('line', [l,r])
+
+
+P0 = b.create('glider', [x0,0,xaxis], {name:'x0'});
+P0a = b.create('point', [function() {return P0.X();},
+			     function() {return f(P0.X());}], {name:''});
+
+P1 = b.create('point', [function() {return nm(P0.X());},
+			    0], {name:''});
+P1a = b.create('point', [function() {return P1.X();},
+			     function() {return f(P1.X());}], {name:''});
+
+P2 = b.create('point', [function() {return nm(P1.X());},
+			    0], {name:''});
+P2a = b.create('point', [function() {return P2.X();},
+			     function() {return f(P2.X());}], {name:''});
+
+P3 = b.create('point', [function() {return nm(P2.X());},
+			    0], {name:''});
+P3a = b.create('point', [function() {return P3.X();},
+			     function() {return f(P3.X());}], {name:''});
+
+P4 = b.create('point', [function() {return nm(P3.X());},
+			    0], {name:''});
+P4a = b.create('point', [function() {return P4.X();},
+			     function() {return f(P4.X());}], {name:''});
+P5 = b.create('point', [function() {return nm(P4.X());},
+			    0], {name:'x5', strokeColor:'black'});
+
+
+
+
+
+P0a.setAttribute({fixed:true});
+P1.setAttribute({fixed:true});
+P1a.setAttribute({fixed:true});
+P2.setAttribute({fixed:true});
+P2a.setAttribute({fixed:true});
+P3.setAttribute({fixed:true});
+P3a.setAttribute({fixed:true});
+P4.setAttribute({fixed:true});
+P4a.setAttribute({fixed:true});
+P5.setAttribute({fixed:true});
+
+sc = '#000000';
+b.create('segment', [P0,P0a], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P0a, P1], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P1,P1a], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P1a, P2], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P2,P2a], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P2a, P3], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P3,P3a], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P3a, P4], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P4,P4a], {strokeColor:sc, strokeWidth:1});
+b.create('segment', [P4a, P5], {strokeColor:sc, strokeWidth:1});
+
+b.create('functiongraph', [f, -1.5, 1.5])
+
+```
+
+
 
 ##### Example: numeric not algebraic
 

CwJ/integrals/area.jmd

@@ -1430,11 +1430,49 @@ The area under a curve approximated by a Riemann sum.
 # url = "riemann.js"
 #CalculusWithJulia.WeaveSupport.JSXGraph(:integrals, url, caption)
 # This is just wrong...
-url = "https://raw.githubusercontent.com/jverzani/CalculusWithJulia.jl/master/CwJ/integrals/riemann.js"
-url = "./riemann.js"
-CalculusWithJulia.WeaveSupport.JSXGraph(url, caption)
+#CalculusWithJulia.WeaveSupport.JSXGraph(url, caption)
+nothing
 ```
 
+```=html
+<div id="jsxgraph" style="width: 500px; height: 500px;"></div>
+```
+
+```ojs
+//| echo: false
+//| output: false
+JXG = require("jsxgraph");
+
+b = JXG.JSXGraph.initBoard('jsxgraph', {
+    boundingbox: [-0.5,0.3,1.5,-1/4], axis:true
+});
+
+g = function(x) { return x*x*x*x +  10*x*x - 60* x + 100}
+f = function(x) {return 1/Math.sqrt(g(x))};
+
+type = "right";
+l = 0;
+r = 1;
+rsum = function() {
+    return JXG.Math.Numerics.riemannsum(f,n.Value(), type, l, r);
+};
+n =   b.create('slider', [[0.1, -0.05],[0.75,-0.05], [2,1,50]],{name:'n',snapWidth:1});
+
+graph = b.create('functiongraph', [f, l, r]);
+os = b.create('riemannsum',
+                  [f,
+                   function(){ return n.Value();},
+                   type, l, r
+                  ],
+                  {fillColor:'#ffff00', fillOpacity:0.3});
+
+b.create('text', [0.1,0.25, function(){
+    return 'Riemann sum='+(rsum().toFixed(4));
+}]);
+```
+
+
+
 
 The interactive graphic shows the area of a right-Riemann sum for different partitions. The function is
 

CwJ/limits/limits.jmd

@@ -384,6 +384,43 @@ get close to $c$ - allows us to gather quickly if a function seems to
 have a limit at $c$, though the precise value of $L$ may be hard to identify.
 
 
+##### Example
+
+This example illustrates the same limit a different way. Sliding the ``x`` value towards ``0`` shows ``f(x) = \sin(x)/x`` approaches a value of ``1``.
+
+
+```=html
+<div id="jsxgraph" style="width: 500px; height: 500px;"></div>
+```
+
+```ojs
+//| echo: false
+//| output: false
+
+JXG = require("jsxgraph")
+
+b = JXG.JSXGraph.initBoard('jsxgraph', {
+    boundingbox: [-6, 1.2, 6,-1.2], axis:true
+});
+
+f = function(x) {return Math.sin(x) / x;};
+graph = b.create("functiongraph", [f, -6, 6])
+seg = b.create("line", [[-6,0], [6,0]], {fixed:true});
+
+X = b.create("glider", [2, 0, seg], {name:"x", size:4});
+P = b.create("point", [function() {return X.X()}, function() {return f(X.X())}], {name:""});
+Q = b.create("point", [0, function() {return P.Y();}], {name:"f(x)"});
+
+segup = b.create("segment", [P,X], {dash:2});
+segover = b.create("segment", [P, [0, function() {return P.Y()}]], {dash:2});
+
+
+txt = b.create('text', [2, 1, function() {
+    return "x = " + X.X().toFixed(4) + ", f(x) = " + P.Y().toFixed(4);
+}]);
+```
+
+
 ##### Example
 
 
@@ -436,8 +473,6 @@ $g(x) = (x-3)/(x+3)$ when $x \neq 2$. The function $g(x)$ is
 $g(2) = (2 - 3)/(2 + 3) = -0.2$ it would be made continuous, hence the
 term removable singularity.
 
-
-
 ## Numerical approaches to limits
 
 The investigation of $\lim_{x \rightarrow 0}(1 + x)^{1/x}$ by