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

typos

Browse Source
This commit is contained in:
jverzani
2024-05-22 07:55:20 -04:00
parent f710cded15
commit 771bb06aa3
50 changed files with 120 additions and 426 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
quarto/misc/getting_started_with_julia.qmd
View File

@@ -19,10 +19,10 @@ As it is open source, indeed with a liberal MIT license, it can be installed for
## Running Julia through the web
There are a few services for running `Julia` through the web. Mentioned here is [Binder](https://mybinder.org), which provides a web-based interface to `Julia` built around `Jupyter`. `Jupyter` is a wildly succesful platform for interacting with different open-source software programs.
There are a few services for running `Julia` through the web. Mentioned here is [Binder](https://mybinder.org), which provides a web-based interface to `Julia` built around `Jupyter`. `Jupyter` is a wildly successful platform for interacting with different open-source software programs.
[lauch binder](https://mybinder.org/v2/gh/CalculusWithJulia/CwJScratchPad.git/master)
[launch binder](https://mybinder.org/v2/gh/CalculusWithJulia/CwJScratchPad.git/master)
Clicking the launch link above will open a web page which provides a blank notebook, save for a package used by these notes. However, `Binder` is nowhere near as reliable as a local installation.

6
quarto/misc/julia_interfaces.qmd
View File

@@ -83,7 +83,7 @@ Pluto has a built-in package management system that manages the installation of
The Jupyter Project provides two web-based interfaces to `Julia`: the Jupyter notebook and the newer JupyterLab. The [binder](https://mybinder.org/) project use Juptyer notebooks for their primary interface to `Julia`. To use a binder notebook, follow this link:
[lauch binder](https://mybinder.org/v2/gh/CalculusWithJulia/CwJScratchPad.git/master)
[launch binder](https://mybinder.org/v2/gh/CalculusWithJulia/CwJScratchPad.git/master)
To run locally, these interfaces are available once `IJulia` is installed. Since version 1.7, the following commands should do this:
@@ -120,7 +120,7 @@ When a cell is evaluating, the leading `[]` has an asterick (`[*]`) showing the
Once a cell is evaluated, the leading `[]` has a number inserted (e.g., `[1]`, as in the figure). This number indicates the order of cell evaluation. Once a notebook is interacted with, the state of the namespace need not reflect the top-to-bottom order of the notebook, but rather reflects the order of cell evaluations.
To be specific, a variable like `x` may be redefined in a cell above where the variable is intially defined and this redefinition will hold the current value known to the interpreter. As well, a notebook, when reloaded, may have unevaluated cells with output showing. These will not influence the state of the kernel until they are evaluated.
To be specific, a variable like `x` may be redefined in a cell above where the variable is initially defined and this redefinition will hold the current value known to the interpreter. As well, a notebook, when reloaded, may have unevaluated cells with output showing. These will not influence the state of the kernel until they are evaluated.
When a cell's commands are evaluated, the last command executed is displayed. If it is desirable that multiple values be displayed, they can be packed into a tuple. This is done by using commas to separate values. `IJulia` will also display other means to print output (e.g., `@show`, `display`, `print`, ...).
@@ -132,7 +132,7 @@ To run all cells in a notebook from top to bottom, the "run all" command under t
If a calculation takes much longer than anticipated, the "kernel" can be interrupted through a menu item of "Kernel".
If the kernal appears unresponsive, it can be restarted through a menu item of "Kernel".
If the kernel appears unresponsive, it can be restarted through a menu item of "Kernel".
Notebooks can be saved (as `*.ipynb` files) for sharing or for reuse. Notebooks can be printed at HTML pages, and if the proper underlying software is available, as formatted pages.

14
quarto/misc/quick_notes.qmd
View File

@@ -52,7 +52,7 @@ Packages can also be loaded through `import PackageName`. Importing does not add
## Types
Objects in `Julia` are "typed." Common numeric types are `Float64`, `Int64` for floating point numbers and integers. Less used here are types like `Rational{Int64}`, specifying rational numbers with a numerator and denominator as `Int64`; or `Complex{Float64}`, specifying a comlex number with floating point components. Julia also has `BigFloat` and `BigInt` for arbitrary precision types. Typically, operations use "promotion" to ensure the combination of types is appropriate. Other useful types are `Function`, an abstract type describing functions; `Bool` for true and false values; `Sym` for symbolic values (through `SymPy`); and `Vector{Float64}` for vectors with floating point components.
Objects in `Julia` are "typed." Common numeric types are `Float64`, `Int64` for floating point numbers and integers. Less used here are types like `Rational{Int64}`, specifying rational numbers with a numerator and denominator as `Int64`; or `Complex{Float64}`, specifying a complex number with floating point components. Julia also has `BigFloat` and `BigInt` for arbitrary precision types. Typically, operations use "promotion" to ensure the combination of types is appropriate. Other useful types are `Function`, an abstract type describing functions; `Bool` for true and false values; `Sym` for symbolic values (through `SymPy`); and `Vector{Float64}` for vectors with floating point components.
For the most part the type will not be so important, but it is useful to know that for some function calls the type of the argument will decide what method ultimately gets called. (This allows symbolic types to interact with Julia functions in an idiomatic manner.)
@@ -175,7 +175,7 @@ Here the number of arguments is used:
```{julia}
Area(w, h) = w * h # area of rectangle
Area(w) = Area(w, w) # area of square using area of rectangle defintion
Area(w) = Area(w, w) # area of square using area of rectangle definition
```
Calling `Area(5)` will call `Area(5,5)` which will return `5*5`.
@@ -294,7 +294,7 @@ We use a few different containers:
x1 = (1, "two", 3.0)
```
Tuples are useful for programming. For example, they are uesd to return multiple values from a function.
Tuples are useful for programming. For example, they are used to return multiple values from a function.
* Vectors. These are objects of the same type (typically) grouped together using square brackets, values separated by commas:
@@ -304,7 +304,7 @@ Tuples are useful for programming. For example, they are uesd to return multiple
x2 = [1, 2, 3.0] # 3.0 makes theses all floating point
```
Unlike tuples, the expected arithmatic from Linear Algebra is implemented for vectors.
Unlike tuples, the expected arithmetic from Linear Algebra is implemented for vectors.
* Matrices. Like vectors, combine values of the same type, only they are 2-dimensional. Use spaces to separate values along a row; semicolons to separate rows:
@@ -628,7 +628,7 @@ ys = [vs[i][2] for i in eachindex(vs)]
plot(xs, ys)
```
This approach is faciliated by the `unzip` function in `CalculusWithJulia` (and used internally by `plot_parametric`):
This approach is facilitated by the `unzip` function in `CalculusWithJulia` (and used internally by `plot_parametric`):
```{julia}
@@ -698,7 +698,7 @@ f(x, y) = 2 - x^2 + y^2
contour(xs, ys, f.(xs, ys'))
```
* An implicit equation. The constraint $f(x,y)=c$ generates an implicit equation. While `contour` can be used for this type of plot - by adjusting the requested contours - the `ImplicitPlots` package does this to make a plot of the equations $f(x,y) = 0$. (The `CalculusWithJulia` package re-uses the `implict_plot` function.)
* An implicit equation. The constraint $f(x,y)=c$ generates an implicit equation. While `contour` can be used for this type of plot - by adjusting the requested contours - the `ImplicitPlots` package does this to make a plot of the equations $f(x,y) = 0$. (The `CalculusWithJulia` package re-uses the `implicit_plot` function.)
```{julia}
@@ -785,7 +785,7 @@ Numerically, the `ForwardDiff.derivative(f, x)` function call will find the deri
ForwardDiff.derivative(sin, pi/3) - cos(pi/3)
```
The `CalculusWithJulia` package overides the `'` (`adjoint`) syntax for functions to provide a derivative which takes a function and returns a function, so its usage is familiar
The `CalculusWithJulia` package overrides the `'` (`adjoint`) syntax for functions to provide a derivative which takes a function and returns a function, so its usage is familiar
```{julia}

8
quarto/misc/toc.qmd
View File

@@ -15,7 +15,7 @@ CalculusWithJulia.WeaveSupport.HTMLoutput(txt)
# Calculus with Julia
`CalculusWithJulia.jl` is a package for a set of notes for learning [calculus](http://en.wikipedia.org/wiki/Calculus) using the `Julia` languge. The package contains some support functions and the files that generate the notes being read now.
`CalculusWithJulia.jl` is a package for a set of notes for learning [calculus](http://en.wikipedia.org/wiki/Calculus) using the `Julia` language. The package contains some support functions and the files that generate the notes being read now.
Since the mid 90s there has been a push to teach calculus using many different points of view. The [Harvard](http://www.math.harvard.edu/~knill/pedagogy/harvardcalculus/) style rule of four says that as much as possible the conversation should include a graphical, numerical, algebraic, and verbal component. These notes use the programming language [Julia](http://julialang.org) to illustrate the graphical, numerical, and, at times, the algebraic aspects of calculus.
@@ -54,7 +54,7 @@ Julia can be used through the internet for free using the [mybinder.org](https:/
Many of the necessary computational skills needed for employing `Julia` successfully to assist in learning calculus are in direct analogy to concepts of mathematics that are first introduced in precalculus or prior. This precalculus *review*, covers some of the basic materials mathematically (though not systematically). More importantly it illustrates the key computational mechanics we will use throughout.
A quick rundown of the `Julia` concepts presented in this setion is in a [Julia overview](precalc/julia_overview.html).
A quick rundown of the `Julia` concepts presented in this section is in a [Julia overview](precalc/julia_overview.html).
### Number systems
@@ -301,7 +301,7 @@ We begin with the generalization of the Riemann integral to compute area to the
* [Double and triple integrals](integral_vector_calculus/double_triple_integrals.html)
Line and surface integrals are computed by 1- and 2-dimensional integrals, but offer new interpretations, espcially when vector fields are considered.
Line and surface integrals are computed by 1- and 2-dimensional integrals, but offer new interpretations, especially when vector fields are considered.
* [Line and surface integrals](integral_vector_calculus/line_integrals.html)
@@ -369,5 +369,3 @@ This is a work in progress. To report an issue, make a comment, or suggest somet
To make edits to the documents directly, a pull request with the modified `*.jmd` files in the `CwJ` directory should be made. Minor edits to the `*.jmd` files should be possible through the GitHub web interface. In the footer of each page a pencil icon accompanying "suggest an edit" when clicked should cause the opening of the corresponding `*.jmd` file on GitHub for suggesting modifications. The html files will be generated independently, that need not be done.