daviddoji/CalculusWithJuliaNotes.jl
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

update work flow

Browse Source
This commit is contained in:
jverzani 2022-07-25 20:51:08 -04:00
parent bce4ce7fa0
commit 6712bb02c4
86 changed files with 489 additions and 2139 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
CwJ/alternatives/plotly_plotting.jmd
View File

@ -1,5 +1,10 @@
# JavaScript based plotting libraries # 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: This section uses this add-on package:
```julia ```julia

34
CwJ/derivatives/mean_value_theorem.jmd
View File

@ -396,7 +396,39 @@ That is the function $f(x)$, minus the secant line between $(a,f(a))$ and $(b, f
nothing 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 ##### Example

90
CwJ/derivatives/newtons_method.jmd
View File

@ -285,6 +285,96 @@ gif(anim, imgfile, fps = 1)
ImageFile(imgfile, caption) 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 ##### Example: numeric not algebraic

44
CwJ/integrals/area.jmd
View File

@ -1430,11 +1430,49 @@ The area under a curve approximated by a Riemann sum.
# url = "riemann.js" # url = "riemann.js"
#CalculusWithJulia.WeaveSupport.JSXGraph(:integrals, url, caption) #CalculusWithJulia.WeaveSupport.JSXGraph(:integrals, url, caption)
# This is just wrong... # This is just wrong...
url = "https://raw.githubusercontent.com/jverzani/CalculusWithJulia.jl/master/CwJ/integrals/riemann.js" #CalculusWithJulia.WeaveSupport.JSXGraph(url, caption)
url = "./riemann.js" nothing
CalculusWithJulia.WeaveSupport.JSXGraph(url, caption)
``` ```
```=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 The interactive graphic shows the area of a right-Riemann sum for different partitions. The function is

39
CwJ/limits/limits.jmd
View File

@ -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. 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 ##### 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 $g(2) = (2 - 3)/(2 + 3) = -0.2$ it would be made continuous, hence the
term removable singularity. term removable singularity.
## Numerical approaches to limits ## Numerical approaches to limits
The investigation of $\lim_{x \rightarrow 0}(1 + x)^{1/x}$ by The investigation of $\lim_{x \rightarrow 0}(1 + x)^{1/x}$ by

2
Project.toml
View File

@ -1,7 +1,7 @@
name = "CalculusWithJuliaNotes" name = "CalculusWithJuliaNotes"
uuid = "8cd3c377-0a30-4ec5-b85a-75291d749efe" uuid = "8cd3c377-0a30-4ec5-b85a-75291d749efe"
authors = ["jverzani <jverzani@gmail.com> and contributors"] authors = ["jverzani <jverzani@gmail.com> and contributors"]
version = "0.1.0" version = "0.1.1"
[compat] [compat]
julia = "1" julia = "1"

28
quarto/ODEs/differential_equations.qmd
View File

@ -1,33 +1,7 @@
# The `DifferentialEquations` suite # The `DifferentialEquations` suite
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/ODEs/euler.qmd
View File

@ -1,33 +1,7 @@
# Euler's method # Euler's method
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/ODEs/odes.qmd
View File

@ -1,33 +1,7 @@
# ODEs # ODEs
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

27
quarto/ODEs/process.jl
View File

@ -1,27 +0,0 @@
using WeavePynb
using Mustache
mmd(fname) = mmd_to_html(fname, BRAND_HREF="../toc.html", BRAND_NAME="Calculus with Julia")
## uncomment to generate just .md files
mmd(fname) = mmd_to_md(fname, BRAND_HREF="../toc.html", BRAND_NAME="Calculus with Julia")
fnames = [
"odes",
"euler"
]
function process_file(nm, twice=false)
include("$nm.jl")
mmd_to_md("$nm.mmd")
markdownToHTML("$nm.md")
twice && markdownToHTML("$nm.md")
end
process_files(twice=false) = [process_file(nm, twice) for nm in fnames]
"""
## TODO ODEs
"""

28
quarto/ODEs/solve.qmd
View File

@ -1,33 +1,7 @@
# The problem-algorithm-solve interface # The problem-algorithm-solve interface
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

9
quarto/README-quarto.md
View File

@ -1,11 +1,13 @@
## TODO ## TODO
* download .jl file (if we have .jmd) * download links to Pluto .jl files (if we have .jmd, but we might deprecate...)
* PlotlyLight
* mermaid, ojs?
DONE * clean up edit link DONE * clean up edit link
DONE * remove pinned header DONE * remove pinned header
DONE * clean up directory DONE * clean up directory
* JSXGraph files DONE (?) * JSXGraph files
* mermaid, ojs?
# CalculusWithJulia via quarto # CalculusWithJulia via quarto
@ -24,6 +26,7 @@ To compile the pages through quarto
* bump the version number in `_quarto.yml`, `Project.toml` * bump the version number in `_quarto.yml`, `Project.toml`
* run `quarto publish gh-pages` to publish * run `quarto publish gh-pages` to publish
* or `quarto publish gh-pages --no-render` to avoid re-rendering, when just done
* should also push project to github * should also push project to github
* no need to push `_freeze` the repo, as files are locally rendered for now. * no need to push `_freeze` the repo, as files are locally rendered for now.

1
quarto/_common_code.qmd
View File

@ -24,5 +24,4 @@ function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString,
end end
nothing nothing
print("all loaded boss")
``` ```

30
quarto/alternatives/plotly_plotting.qmd
View File

@ -1,33 +1,13 @@
# JavaScript based plotting libraries # JavaScript based plotting libraries
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging :::{.callout-note}
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info ## Not working with quarto
Logging.disable_logging(Logging.Warn) Currently, the plots generated here are not rendering within quarto.
import SymPy :::
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses this add-on package: This section uses this add-on package:

28
quarto/derivatives/curve_sketching.qmd
View File

@ -1,33 +1,7 @@
# Curve Sketching # Curve Sketching
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses the following add-on packages: This section uses the following add-on packages:

28
quarto/derivatives/derivatives.qmd
View File

@ -1,33 +1,7 @@
# Derivatives # Derivatives
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/derivatives/first_second_derivatives.qmd
View File

@ -1,33 +1,7 @@
# The first and second derivatives # The first and second derivatives
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/derivatives/implicit_differentiation.qmd
View File

@ -1,33 +1,7 @@
# Implicit Differentiation # Implicit Differentiation
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/derivatives/lhospitals_rule.qmd
View File

@ -1,33 +1,7 @@
# L'Hospital's Rule # L'Hospital's Rule
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/derivatives/linearization.qmd
View File

@ -1,33 +1,7 @@
# Linearization # Linearization
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

62
quarto/derivatives/mean_value_theorem.qmd
View File

@ -1,33 +1,7 @@
# The mean value theorem for differentiable functions. # The mean value theorem for differentiable functions.
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:
@ -390,7 +364,39 @@ That is the function $f(x)$, minus the secant line between $(a,f(a))$ and $(b, f
nothing 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 ##### Example

28
quarto/derivatives/more_zeros.qmd
View File

@ -1,33 +1,7 @@
# Derivative-free alternatives to Newton's method # Derivative-free alternatives to Newton's method
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

119
quarto/derivatives/newtons_method.qmd
View File

@ -1,33 +1,7 @@
# Newton's method # Newton's method
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:
@ -311,6 +285,97 @@ gif(anim, imgfile, fps = 1)
ImageFile(imgfile, caption) 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 ##### Example: numeric not algebraic

28
quarto/derivatives/numeric_derivatives.qmd
View File

@ -1,33 +1,7 @@
# Numeric derivatives # Numeric derivatives
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/derivatives/optimization.qmd
View File

@ -1,33 +1,7 @@
# Optimization # Optimization
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

44
quarto/derivatives/process.jl
View File

@ -1,44 +0,0 @@
using WeavePynb
using CwJWeaveTpl
fnames = [
"derivatives", ## more questions
"numeric_derivatives",
"mean_value_theorem",
"optimization",
"curve_sketching",
"linearization",
"newtons_method",
"lhopitals_rule", ## Okay - -but could beef up questions..
"implicit_differentiation", ## add more questions?
"related_rates",
"taylor_series_polynomials"
]
process_file(nm; cache=:off) = CwJWeaveTpl.mmd(nm * ".jmd", cache=cache)
function process_files(;cache=:user)
for f in fnames
@show f
process_file(f, cache=cache)
end
end
"""
## TODO derivatives
tangent lines intersect at avearge for a parabola
Should we have derivative results: inverse functions, logarithmic differentiation...
"""

28
quarto/derivatives/related_rates.qmd
View File

@ -1,33 +1,7 @@
# Related rates # Related rates
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packaages: This section uses these add-on packaages:

28
quarto/derivatives/symbolic_derivatives.qmd
View File

@ -1,33 +1,7 @@
# Symbolic derivatives # Symbolic derivatives
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses this add-on package: This section uses this add-on package:

28
quarto/derivatives/taylor_series_polynomials.qmd
View File

@ -1,33 +1,7 @@
# Taylor Polynomials and other Approximating Polynomials # Taylor Polynomials and other Approximating Polynomials
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/differentiable_vector_calculus/plots_plotting.qmd
View File

@ -1,33 +1,7 @@
# 2D and 3D plots in Julia with Plots # 2D and 3D plots in Julia with Plots
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/differentiable_vector_calculus/polar_coordinates.qmd
View File

@ -1,33 +1,7 @@
# Polar Coordinates and Curves # Polar Coordinates and Curves
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

36
quarto/differentiable_vector_calculus/process.jl
View File

@ -1,36 +0,0 @@
using WeavePynb
using Mustache
mmd(fname) = mmd_to_html(fname, BRAND_HREF="../toc.html", BRAND_NAME="Calculus with Julia")
## uncomment to generate just .md files
#mmd(fname) = mmd_to_md(fname, BRAND_HREF="../toc.html", BRAND_NAME="Calculus with Julia")
fnames = ["polar_coordinates",
"vectors",
"vector_valued_functions",
"scalar_functions",
"scalar_functions_applications",
"vector_fields"
]
function process_file(nm, twice=false)
include("$nm.jl")
mmd_to_md("$nm.mmd")
markdownToHTML("$nm.md")
twice && markdownToHTML("$nm.md")
end
process_files(twice=false) = [process_file(nm, twice) for nm in fnames]
"""
## TODO differential_vector_calcululs
### Add questions for scalar_function_applications
* Newton's method??
* optimization. Find least squares for perpendicular distance using the same 3 points...??
"""

28
quarto/differentiable_vector_calculus/scalar_functions.qmd
View File

@ -1,33 +1,7 @@
# Scalar functions # Scalar functions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/differentiable_vector_calculus/scalar_functions_applications.qmd
View File

@ -1,33 +1,7 @@
# Applications with scalar functions # Applications with scalar functions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/differentiable_vector_calculus/vector_fields.qmd
View File

@ -1,33 +1,7 @@
# Functions $R^n \rightarrow R^m$ # Functions $R^n \rightarrow R^m$
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/differentiable_vector_calculus/vector_valued_functions.qmd
View File

@ -1,33 +1,7 @@
# Vector-valued functions, $f:R \rightarrow R^n$ # Vector-valued functions, $f:R \rightarrow R^n$
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/differentiable_vector_calculus/vectors.qmd
View File

@ -1,33 +1,7 @@
# Vectors and matrices # Vectors and matrices
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on package: This section uses these add-on package:

28
quarto/integral_vector_calculus/div_grad_curl.qmd
View File

@ -1,33 +1,7 @@
# The Gradient, Divergence, and Curl # The Gradient, Divergence, and Curl
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integral_vector_calculus/double_triple_integrals.qmd
View File

@ -1,33 +1,7 @@
# Multi-dimensional integrals # Multi-dimensional integrals
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integral_vector_calculus/line_integrals.qmd
View File

@ -1,33 +1,7 @@
# Line and Surface Integrals # Line and Surface Integrals
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

35
quarto/integral_vector_calculus/process.jl
View File

@ -1,35 +0,0 @@
using WeavePynb
using Mustache
mmd(fname) = mmd_to_html(fname, BRAND_HREF="../toc.html", BRAND_NAME="Calculus with Julia")
## uncomment to generate just .md files
#mmd(fname) = mmd_to_md(fname, BRAND_HREF="../toc.html", BRAND_NAME="Calculus with Julia")
fnames = [
"double_triple_integrals",
"line_integrals",
"div_grad_curl",
"stokes_theorem",
"review"
]
function process_file(nm, twice=false)
include("$nm.jl")
mmd_to_md("$nm.mmd")
markdownToHTML("$nm.md")
twice && markdownToHTML("$nm.md")
end
process_files(twice=false) = [process_file(nm, twice) for nm in fnames]
"""
## TODO integral_vector_calculus
* line integrals needs an image (lasso?)
* more questions
"""

28
quarto/integral_vector_calculus/review.qmd
View File

@ -1,33 +1,7 @@
# Quick Review of Vector Calculus # Quick Review of Vector Calculus
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false

28
quarto/integral_vector_calculus/stokes_theorem.qmd
View File

@ -1,33 +1,7 @@
# Green's Theorem, Stokes' Theorem, and the Divergence Theorem # Green's Theorem, Stokes' Theorem, and the Divergence Theorem
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/arc_length.qmd
View File

@ -1,33 +1,7 @@
# Arc length # Arc length
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

70
quarto/integrals/area.qmd
View File

@ -1,33 +1,7 @@
# Area under a curve # Area under a curve
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:
@ -1442,9 +1416,45 @@ The area under a curve approximated by a Riemann sum.
# url = "riemann.js" # url = "riemann.js"
#CalculusWithJulia.WeaveSupport.JSXGraph(:integrals, url, caption) #CalculusWithJulia.WeaveSupport.JSXGraph(:integrals, url, caption)
# This is just wrong... # This is just wrong...
url = "https://raw.githubusercontent.com/jverzani/CalculusWithJulia.jl/master/CwJ/integrals/riemann.js" #CalculusWithJulia.WeaveSupport.JSXGraph(url, caption)
url = "./riemann.js" nothing
CalculusWithJulia.WeaveSupport.JSXGraph(url, caption) ```
```{=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 The interactive graphic shows the area of a right-Riemann sum for different partitions. The function is

28
quarto/integrals/area_between_curves.qmd
View File

@ -1,33 +1,7 @@
# Area between two curves # Area between two curves
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/center_of_mass.qmd
View File

@ -1,33 +1,7 @@
# Center of Mass # Center of Mass
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/ftc.qmd
View File

@ -1,33 +1,7 @@
# Fundamental Theorem or Calculus # Fundamental Theorem or Calculus
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/improper_integrals.qmd
View File

@ -1,33 +1,7 @@
# Improper Integrals # Improper Integrals
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/integration_by_parts.qmd
View File

@ -1,33 +1,7 @@
# Integration By Parts # Integration By Parts
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/mean_value_theorem.qmd
View File

@ -1,33 +1,7 @@
# Mean value theorem for integrals # Mean value theorem for integrals
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/partial_fractions.qmd
View File

@ -1,33 +1,7 @@
# Partial Fractions # Partial Fractions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
using CalculusWithJulia using CalculusWithJulia

41
quarto/integrals/process.jl
View File

@ -1,41 +0,0 @@
fnames = [
"area",
"ftc",
"substitution",
"integration_by_parts",
"partial_fractions", # XX add in trig integrals (cos()sin() stuff? mx or ^m... XXX
"improper_integrals", ##
"mean_value_theorem",
"area_between_curves",
"center_of_mass",
"volumes_slice",
#"volumes_shell", ## XXX add this in if needed, but not really that excited to now XXX
"arc_length",
"surface_area"
]
function process_file(nm, twice=false)
include("$nm.jl")
mmd_to_md("$nm.mmd")
markdownToHTML("$nm.md")
twice && markdownToHTML("$nm.md")
end
process_files(twice=false) = [process_file(nm, twice) for nm in fnames]
"""
## TODO integrals
* add in volumes shell???
* mean value theorem is light?
* could add surface area problems
"""

28
quarto/integrals/substitution.qmd
View File

@ -1,33 +1,7 @@
# Substitution # Substitution
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/surface_area.qmd
View File

@ -1,33 +1,7 @@
# Surface Area # Surface Area
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/integrals/volumes_slice.qmd
View File

@ -1,33 +1,7 @@
# Volumes by slicing # Volumes by slicing
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/limits/continuity.qmd
View File

@ -1,33 +1,7 @@
# Continuity # Continuity
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

28
quarto/limits/intermediate_value_theorem.qmd
View File

@ -1,33 +1,7 @@
# Implications of continuity # Implications of continuity
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses these add-on packages: This section uses these add-on packages:

65
quarto/limits/limits.qmd
View File

@ -1,33 +1,7 @@
# Limits # Limits
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses the following add-on packages: This section uses the following add-on packages:
@ -407,6 +381,43 @@ The graphical approach to limits - plotting $f(x)$ around $c$ and observing if t
##### Example ##### 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
Consider now the following limit Consider now the following limit

28
quarto/limits/limits_extensions.qmd
View File

@ -1,33 +1,7 @@
# Limits, issues, extensions of the concept # Limits, issues, extensions of the concept
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses the following add-on packages: This section uses the following add-on packages:

26
quarto/limits/process.jl
View File

@ -1,26 +0,0 @@
using CwJWeaveTpl
fnames = [
"limits",
"limits_extensions",
#
"continuity",
"intermediate_value_theorem"
]
process_file(nm; cache=:off) = CwJWeaveTpl.mmd(nm * ".jmd", cache=cache)
function process_files(;cache=:user)
for f in fnames
@show f
process_file(f, cache=cache)
end
end
"""
## TODO limits
"""

1
quarto/make_qmd.jl
View File

@ -45,6 +45,7 @@ for DIR ∈ DIRS
else else
_, ext = splitext(f) _, ext = splitext(f)
ext == ".toml" && continue ext == ".toml" && continue
f == "process.jl" && continueg
@show :cp, f @show :cp, f
try try
force = isfile(joinpath(DIR, f)) force = isfile(joinpath(DIR, f))

28
quarto/misc/calculus_with_julia.qmd
View File

@ -1,33 +1,7 @@
# The `CalculusWithJulia` package # The `CalculusWithJulia` package
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
To run the commands in these notes, some external packages must be installed and loaded. To run the commands in these notes, some external packages must be installed and loaded.

28
quarto/misc/getting_started_with_julia.qmd
View File

@ -1,33 +1,7 @@
# Getting started with Julia # Getting started with Julia
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false

28
quarto/misc/julia_interfaces.qmd
View File

@ -1,33 +1,7 @@
# Julia interfaces # Julia interfaces
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false

28
quarto/misc/quick_notes.qmd
View File

@ -1,33 +1,7 @@
# Quick introduction to Calculus with Julia # Quick introduction to Calculus with Julia
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
The `Julia` programming language with a design that makes it well suited as a supplement for the learning of calculus, as this collection of notes is intended to illustrate. The `Julia` programming language with a design that makes it well suited as a supplement for the learning of calculus, as this collection of notes is intended to illustrate.

28
quarto/misc/toc.qmd
View File

@ -10,33 +10,7 @@ txt = """
CalculusWithJulia.WeaveSupport.HTMLoutput(txt) CalculusWithJulia.WeaveSupport.HTMLoutput(txt)
``` ```
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
# Calculus with Julia # Calculus with Julia

28
quarto/misc/unicode.qmd
View File

@ -1,33 +1,7 @@
# Usages of Unicode symbols # Usages of Unicode symbols
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
`Julia` allows the use of *Unicode* symbols to replace variable names and for function calls. Unicode operations are entered in this pattern `\name[tab]`. That is a slash, `\`, the name (e.g., `alpha`), and then a press of the `tab` key. `Julia` allows the use of *Unicode* symbols to replace variable names and for function calls. Unicode operations are entered in this pattern `\name[tab]`. That is a slash, `\`, the name (e.g., `alpha`), and then a press of the `tab` key.

28
quarto/misc/using-pluto.qmd
View File

@ -1,33 +1,7 @@
# Using Pluto # Using Pluto
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
:::{.callout-note} :::{.callout-note}
## Note ## Note

28
quarto/precalc/calculator.qmd
View File

@ -1,33 +1,7 @@
# From calculator to computer # From calculator to computer
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false

28
quarto/precalc/exp_log_functions.qmd
View File

@ -1,33 +1,7 @@
# Exponential and logarithmic functions # Exponential and logarithmic functions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses the following add-on packages: This section uses the following add-on packages:

28
quarto/precalc/functions.qmd
View File

@ -1,33 +1,7 @@
# Functions # Functions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section will use the following add-on packages: This section will use the following add-on packages:

28
quarto/precalc/inversefunctions.qmd
View File

@ -1,33 +1,7 @@
# The Inverse of a Function # The Inverse of a Function
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
In this section we will use these add-on packages: In this section we will use these add-on packages:

28
quarto/precalc/julia_overview.qmd
View File

@ -1,33 +1,7 @@
# Overview of Julia commands # Overview of Julia commands
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false

28
quarto/precalc/logical_expressions.qmd
View File

@ -1,33 +1,7 @@
# Inequalities, Logical expressions # Inequalities, Logical expressions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
In this section we use the following package: In this section we use the following package:

28
quarto/precalc/numbers_types.qmd
View File

@ -1,33 +1,7 @@
# Number systems # Number systems
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false

28
quarto/precalc/plotting.qmd
View File

@ -1,33 +1,7 @@
# The Graph of a Function # The Graph of a Function
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section will use the following packages: This section will use the following packages:

28
quarto/precalc/polynomial.qmd
View File

@ -1,33 +1,7 @@
# Polynomials # Polynomials
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
In this section we use the following add-on packages: In this section we use the following add-on packages:

28
quarto/precalc/polynomial_roots.qmd
View File

@ -1,33 +1,7 @@
# Roots of a polynomial # Roots of a polynomial
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
In this section we use the following add on packages: In this section we use the following add on packages:

28
quarto/precalc/polynomials_package.qmd
View File

@ -1,33 +1,7 @@
# The Polynomials package # The Polynomials package
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section will use the following add-on packages: This section will use the following add-on packages:

28
quarto/precalc/ranges.qmd
View File

@ -1,33 +1,7 @@
# Ranges and Sets # Ranges and Sets
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false

28
quarto/precalc/rational_functions.qmd
View File

@ -1,33 +1,7 @@
# Rational functions # Rational functions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses the following add-on packages: This section uses the following add-on packages:

28
quarto/precalc/transformations.qmd
View File

@ -1,33 +1,7 @@
# Function manipulations # Function manipulations
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
In this section we will use these add-on packages: In this section we will use these add-on packages:

28
quarto/precalc/trig_functions.qmd
View File

@ -1,33 +1,7 @@
# Trigonometric functions # Trigonometric functions
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
This section uses the following add-on packages: This section uses the following add-on packages:

28
quarto/precalc/variables.qmd
View File

@ -1,33 +1,7 @@
# Variables # Variables
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
## Assignment ## Assignment

28
quarto/precalc/vectors.qmd
View File

@ -1,33 +1,7 @@
# Vectors # Vectors
```{julia} {{< include ../_common_code.qmd >}}
#| echo: false
import Logging
Logging.disable_logging(Logging.Info) # or e.g. Logging.Info
Logging.disable_logging(Logging.Warn)
import SymPy
function Base.show(io::IO, ::MIME"text/html", x::T) where {T <: SymPy.SymbolicObject}
println(io, "<span class=\"math-left-align\" style=\"padding-left: 4px; width:0; float:left;\"> ")
println(io, "\\[")
println(io, sympy.latex(x))
println(io, "\\]")
println(io, "</span>")
end
# hack to work around issue
import Markdown
import CalculusWithJulia
function CalculusWithJulia.WeaveSupport.ImageFile(d::Symbol, f::AbstractString, caption; kwargs...)
nm = joinpath("..", string(d), f)
u = "![$caption]($nm)"
Markdown.parse(u)
end
nothing
```
```{julia} ```{julia}
#| echo: false #| echo: false