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

lots of cleanup

Browse Source
This commit is contained in:
jverzani
2026-08-11 17:17:08 -04:00
parent ae461659e0
commit 253295ff6e
91 changed files with 18284 additions and 7872 deletions
Download Patch File Download Diff File Expand all files Collapse all files

166
quarto/basics/calculator.qmd
View File

@@ -12,22 +12,16 @@ nothing
Let us consider a basic calculator with buttons to add, subtract, multiply, divide, and take square roots. Using such a simple thing is certainly familiar for any reader of these notes. Indeed, a familiarity with a *graphing* calculator is expected. `Julia` makes these familiar tasks just as easy, offering numerous conveniences along the way. In this section we describe how.
The following image is the calculator that Google presents upon searching for "calculator."
::: {#fig-google-calculator-screenshot-1}
![](figures/calculator.png)
Screenshot of a calculator provided by the Google search engine
:::
```{julia}
#| echo: false
#
imgfile = "figures/calculator.png"
caption = "Screenshot of a calculator provided by the Google search engine."
# ImageFile(:precalc, imgfile, caption)
nothing
```
![Screenshot of a calculator provided by the Google search engine.](./figures/calculator.png)
This calculator should have a familiar appearance with a keypad of numbers, a set of buttons for arithmetic operations, a set of buttons for some common mathematical functions, a degree/radian switch, and buttons for interacting with the calculator: `Ans`, `AC` (also `CE`), and `=`.
@fig-google-calculator-screenshot-1 is a screenshot of a calculator that Google presented upon searching for "calculator". This calculator should have a familiar appearance with a keypad of numbers, a set of buttons for arithmetic operations, a set of buttons for some common mathematical functions, a degree/radian switch, and buttons for interacting with the calculator: `Ans`, `AC` (also `CE`), and `=`.
The goal here is to see the counterparts within `Julia` to these features.
@@ -60,17 +54,16 @@ Performing a simple computation on the calculator typically involves hitting but
1 + 2
```
Sending an expression to `Julia`'s interpreter - the equivalent of pressing the "`=`" key on a calculator - is done at the command line by pressing the `Enter` or `Return` key, and in `Pluto`, also using the "play" icon, or the keyboard shortcut `Shift-Enter`. If the current expression is complete, then `Julia` evaluates it and shows any output. If the expression is not complete, `Julia`'s response depends on how it is being called. Within `Pluto`, a message about "`premature end of input`" is given. If the expression raises an error, this will be noted.
Sending an expression to `Julia`'s interpreter---the equivalent of pressing the "`=`" key on a calculator---is done at the command line by pressing the `Enter` or `Return` key. If the current expression is complete, then `Julia` evaluates it and shows any output. If the expression is not complete, `Julia`'s response at the command line pauses for more input. Other interfaces may have variations of the above.
The basic arithmetic operations on a calculator are "+", "-", "×", "÷", and "$xʸ$". These have parallels in `Julia` through the *binary* operators: `+`, `-`, `*`, `/`, and `^`:
The basic arithmetic operations on a calculator are +, -, ×, ÷ and xʸ. These have parallels in `Julia` through the *binary* operators: `+`, `-`, `*`, `/`, and `^`:
```{julia}
1 + 2, 2 - 3, 3 * 4, 4 / 5, 5 ^ 6
```
On some calculators, there is a distinction between minus signs - the binary minus sign and the unary minus sign to create values such as $-1$.
On some calculators, there is a distinction between minus signs---the binary minus sign and the unary minus sign to create values such as $-1$.
In `Julia`, the same symbol, "`-`", is used for each:
@@ -89,7 +82,7 @@ An expression like $6 - -3$, subtracting minus three from six, must be handled w
(If no space is included, the value "`--`" is parsed like a different, invalid, operation.)
:::{.callout-warning}
::: {.callout-warning}
## Warning
`Julia` only uses one symbol for minus, but web pages may not! Copying
and pasting an expression with a minus sign can lead to hard to
@@ -101,13 +94,10 @@ the typeset math (e.g., $1 - \pi$) than for the code within cells
:::
### Examples
##### Example: Celsius and Fahrenheit
##### Example
For everyday temperatures, the conversion from Celsius to Fahrenheit ($9/5 C + 32$) is well approximated by simply doubling and adding $30$. Compare these values for an average room temperature, $C=20$, and for a relatively chilly day, $C=5$:
For everyday temperatures, the conversion from Celsius to Fahrenheit ($9/5\cdot C + 32$) is well approximated by simply doubling and adding $30$. Compare these values for an average room temperature, $C=20$, and for a relatively chilly day, $C=5$:
For $C=20$:
@@ -188,7 +178,7 @@ A right triangle has sides $a=11$ and $b=12$. Find the length of the hypotenus
11^2 + 12^2
```
##### Example
##### Example: How many ants?
An overview of a research paper published in [theconversation.com](https://theconversation.com/earth-harbours-20-000-000-000-000-000-ants-and-they-weigh-more-than-wild-birds-and-mammals-combined-190831) reviews six authors' work on estimating the number of ants currently on earth. This was covered in an
article in the [Washington Post](https://www.washingtonpost.com/climate-environment/2022/09/19/ants-population-20-quadrillion/).
@@ -244,7 +234,7 @@ With the Google Calculator, typing `1 + 2 x 3 =` will give the value $7$, but *i
In `Julia`, the entire expression is typed in before being evaluated, so the usual conventions of mathematics related to the order of operations may be used. These are colloquially summarized by the acronym [PEMDAS](http://en.wikipedia.org/wiki/Order_of_operations).
> **PEMDAS**. This acronym stands for Parentheses, Exponents, Multiplication, Division, Addition, Subtraction. The order indicates which operation has higher precedence, or should happen first. This isn't exactly the case, as "M" and "D" have the same precedence, as do "A" and "S". In the case of two operations with equal precedence, *associativity* is used to decide which to do. For the operations `-`, `/` the associativity is left to right, as in the left one is done first, then the right. However, `^` has right associativity, so `4^3^2` is `4^(3^2)` and not `(4^3)^2` (Be warned that some calculators - and spread sheets, such as Excel - will treat this expression with left associativity). But, `+` and `*` don't have associativity, so `1+2+3` can be `(1+2)+3` or `1+(2+3)`.
> **PEMDAS**. This acronym stands for Parentheses, Exponents, Multiplication, Division, Addition, Subtraction. The order indicates which operation has higher precedence, or should happen first. This isn't exactly the case, as "M" and "D" have the same precedence, as do "A" and "S". In the case of two operations with equal precedence, *associativity* is used to decide which to do. For the operations `-`, `/` the associativity is left to right, as in the left one is done first, then the right. However, `^` has right associativity, so `4^3^2` is `4^(3^2)` and not `(4^3)^2` (Be warned that some calculators---and spread sheets, such as Excel---will treat this expression with left associativity). The operators `+` and `*` are called associative, which means the order doesn't matter, so `1+2+3` can be `(1+2)+3` or `1+(2+3)`.^[Well, mathematically, floating point math has well known cases for `+` where associativity does not hold, such as `(0.1 + 0.2) + 0.3` not begin exactly equal to `0.1 + (0.2 + 0.3)`]
@@ -269,8 +259,6 @@ If different parentheses are used, the answer will likely be different. For exam
(1 + ((2 - 3) * 4)) / (5 ^ 6)
```
### Examples
##### Example
@@ -284,6 +272,20 @@ The percentage error in $x$ if $y$ is the correct value is $(x-y)/y \cdot 100$.
##### Example
The *percentage decrease* of an item is $(o-n)/o \cdot 100$ with $o$ being the original price and $n$ being the new one. If a drug that cost 60 dollars is not 55 dollars what is the percentage decrease?
```{julia}
(60 - 50) / 60 * 100
```
The "different way of doing math" would compute this as $(o-n)/n \cdot 100$. With that unusual style, this nonmathematical value is:
```{julia}
(60 - 50)/50 * 100
```
##### Example
The marginal cost of producing one unit can be computed by finding the cost for $n+1$ units and subtracting the cost for $n$ units. If the cost of $n$ units is $n^2 + 10$, find the marginal cost when $n=100$.
@@ -312,7 +314,7 @@ The slope of the line through two points is $m=(y_1 - y_0) / (x_1 - x_0)$. For t
(4 - 2) / (3 - 1)
```
### Two ways to write division - and they are not the same
### Two ways to write division
The expression $a + b / c + d$ is equivalent to $a + (b/c) + d$ due to the order of operations. It will generally have a different answer than $(a + b) / (c + d)$.
@@ -325,7 +327,7 @@ $$
\frac{1 + 2}{3 + 4}?
$$
It would have to be computed through $(1 + 2) / (3 + 4)$. This is because unlike `/`, the implied order of operation in the mathematical notation with the *horizontal division symbol* (the [vinculum](http://tinyurl.com/y9tj6udl)) is to compute the top and the bottom and then divide. That is, the vincula is a grouping notation like parentheses, only implicitly so. Thus the above expression really represents the more verbose:
It would have to be computed through $(1 + 2) / (3 + 4)$. This is because unlike `/`, the implied order of operations in the mathematical notation with the *horizontal division symbol* (the [vinculum](http://tinyurl.com/y9tj6udl)) is to compute the top and the bottom and then divide. That is, the vincula is a grouping notation like parentheses, only implicitly so. Thus the above expression really represents the more verbose:
$$
@@ -346,7 +348,7 @@ To emphasize, this is not the same as the value without the parentheses:
1 + 2 / 3 + 4
```
:::{.callout-warning}
::: {.callout-warning}
## Warning
The vinculum also indicates grouping when used with the square root (the top bar), and complex conjugation. That usage is often clear enough, but the usage of the vinculum in division often leads to confusion. The example above is one where the parentheses are often, erroneously, omitted. However, more confusion can arise when there is more than one vincula. An expression such as $a/b/c$ written inline has no confusion, it is: $(a/b) / c$ as left association is used; but when written with a pair of vincula there is often the typographical convention of a slightly longer vincula to indicate which is to be considered first. In the absence of that, then top to bottom association is often implied.
@@ -406,7 +408,7 @@ In most cases. There are occasional (basically rare) spots where using `pi` by i
### Numeric literals
For some special cases, Julia parses *multiplication* without a multiplication symbol. One case is when the value on the left is a number, as in `2pi`, which has an equivalent value to `2*pi`. *However* the two are not equivalent, in that multiplication with *numeric literals* does not have the same precedence as regular multiplication - it is higher. This has practical importance when used in division or powers. For instance, these two expressions are **not** the same:
For some special cases, Julia parses *multiplication* without a multiplication symbol. One case is when the value on the left is a number, as in `2pi`, which has an equivalent value to `2*pi`. *However* the two are not equivalent, in that multiplication with *numeric literals* does not have the same precedence as regular multiplication---**it is higher**. This has practical importance when used in division or powers. For instance, these two expressions are **not** the same:
```{julia}
@@ -439,44 +441,28 @@ This follows usual mathematical convention, but is a source of potential confusi
On the Google calculator, the square root button has a single purpose: for the current value find a square root if possible, and if not signal an error (such as what happens if the value is negative). For more general powers, the $x^y$ key can be used.
In `Julia`, functions are used to perform the actions that a specialized button may do on the calculator. `Julia` provides many standard mathematical functions - more than there could be buttons on a calculator - and allows the user to easily define their own functions. For example, `Julia` provides the same set of functions as on Google's calculator, though with different names. For logarithms, $\ln$ becomes `log` and $\log$ is `log10` (computer programs almost exclusively reserve `log` for the natural log); for factorials, $x!$, there is `factorial`; for powers $\sqrt{...}$ becomes `sqrt`, $EXP$ becomes `exp`, and $x^y$ is computed with the infix operator `^`. For the trigonometric functions, the basic names are similar: `sin`, `cos`, `tan`. These expect radians. For angles in degrees, the convenience functions `sind`, `cosd`, and `tand` are provided. On the calculator, inverse functions like $\sin^{-1}(x)$ are done by combining $Inv$ with $\sin$. With `Julia`, the function name is `asin`, an abbreviation for "arcsine." (Which is a good thing, as the notation using a power of $-1$ is often a source of confusion and is not supported by `Julia` without work.) Similarly, there are `asind`, `acos`, `acosd`, `atan`, and `atand` functions available to the `Julia` user.
In `Julia`, functions are used to perform the actions that a specialized button may do on the calculator. `Julia` provides many standard mathematical functions---more than there could be buttons on a calculator---and allows the user to easily define their own functions. For example, `Julia` provides the same set of functions as on Google's calculator, though with different names. For logarithms, $\ln$ becomes `log` and $\log$ is `log10` (computer programs almost exclusively reserve `log` for the natural log); for factorials, $x!$, there is `factorial`; for powers $\sqrt{...}$ becomes `sqrt`, $EXP$ becomes `exp`, and $x^y$ is computed with the infix operator `^`. For the trigonometric functions, the basic names are similar: `sin`, `cos`, `tan`. These expect radians. For angles in degrees, the convenience functions `sind`, `cosd`, and `tand` are provided. On the calculator, inverse functions like $\sin^{-1}(x)$ are done by combining $Inv$ with $\sin$. With `Julia`, the function name is `asin`, an abbreviation for "arcsine." (Which is a good thing, as the notation using a power of $-1$ is often a source of confusion.) Similarly, there are `asind`, `acos`, `acosd`, `atan`, and `atand` functions available to the `Julia` user.
@tbl-calculator-and-julia-counterparts shows the counterparts between a calculator's dedicated buttons and `Julia` functions.
The following table summarizes the above:
::: {#tbl-calculator-and-julia-counterparts .striped .hover}
| Calculator | Julia |
| ------------------------------------:| ----------------------------------------------:|
| $+$, $-$, $\times$, $\div$ | `+`, `-`, `*`, `/` |
| $x^y$ | `^` |
| $\sqrt{...}$, $\sqrt[3]{...}$ | `sqrt`, `cbrt` |
| $EXP$, $e^x$ | `exp` |
| $\ln$, $\log$ | `log`, `log10` |
| $\sin, \cos, \tan, \sec, \csc, \cot$ | `sin`, `cos`, `tan`, `sec`, `csc`, `cot` |
| In degrees, not radians | `sind`, `cosd`, `tand`, `secd`, `cscd`, `cotd` |
| $\sin^{-1}, \cos^{-1}, \tan^{-1}$ | `asin`, `acos`, `atan` |
| $n!$ | `factorial` |
```{julia}
#| echo: false
using DataFrames
calc = [
L" $+$, $-$, $\times$, $\div$",
L"x^y",
L"\sqrt{...}, \sqrt[3]{...}",
L"e^x",
L" $\ln$, $\log$",
L"\sin, \cos, \tan, \sec, \csc, \cot",
"In degrees, not radians",
L"\sin^{-1}, \cos^{-1}, \tan^{-1}",
L"n!",
]
: Table matching up common buttons on a scientific calculator with `Julia` functions
:::
julia = [
"`+`, `-`, `*`, `/`",
"`^`",
"`sqrt`, `cbrt`",
"`exp`",
"`log`, `log10`",
"`sin`, `cos`, `tan`, `sec`, `csc`, `cot`",
"`sind`, `cosd`, `tand`, `secd`, `cscd`, `cotd`",
"`asin`, `acos`, `atan`",
"`factorial`"
]
d = DataFrame(Calculator=calc, Julia=julia)
Table(d)
```
Using a function is very straightforward. A function is called using parentheses, in a manner visually similar to how a function is called mathematically. So if we consider the `sqrt` function, we have:
@@ -498,7 +484,7 @@ exp(2), log(10), sqrt(100), 10^(1/2)
:::{.callout-note}
## Note
Parentheses have many roles. We've just seen that parentheses may be used for grouping, and now we see they are used to indicate a function is being called. These are familiar from their parallel usage in traditional math notation. In `Julia`, a third usage is common, the making of a "tuple," or a container of different objects, for example `(1, sqrt(2), pi)`. In these notes, the output of multiple commands separated by commas is a printed tuple.
Parentheses have many roles. We've just seen that parentheses may be used for grouping, and now we see they are used to indicate a function is being called. These are familiar from their parallel usage in traditional math notation. In `Julia`, a third usage is common, the making of a "tuple," or a container of different objects, for example `(1, sqrt(2), pi)`. In these notes, the output of multiple commands separated by commas is a printed tuple, as with the previous output.
:::
@@ -518,8 +504,6 @@ log(e), log(2, e), log(10, e), log(e, 2)
In `Julia`, the "generic" function `log` not only has different implementations for different types of arguments (real or complex), but also a different implementation depending on the number of arguments.
### Examples
##### Example
@@ -567,7 +551,10 @@ The formula to compute the resistance of two resistors in parallel is given by:
Not all computations on a calculator are valid. For example, the Google calculator will display `Error` as the output of $0/0$ or $\sqrt{-1}$. These are also errors mathematically, though the second is not if the complex numbers are considered.
In `Julia`, there is a richer set of error types. The value `0/0` will in fact not be an error, but rather a value `NaN`. This is a special floating point value indicating "not a number" and is the result for various operations. The output of $\sqrt{-1}$ (computed via `sqrt(-1)`) will indicate a domain error:
In `Julia`, there is a richer set of error types. The value `0/0` will in fact not be an error, but rather a value `NaN`. This is a special floating point value indicating "not a number" and is the result for various operations.
The output of $\sqrt{-1}$ (computed via `sqrt(-1)`) will indicate a domain error:
```{julia}
#| error: true
@@ -592,7 +579,7 @@ On a machine with $64$-bit integers, the first of these two values is correct, t
Wrong is in quotes, as though they are mathematically incorrect, computationally they are correct. The last two are due to overflow. The cost of checking is considered too high, so no error is thrown and the values represent what happens at the machine level.
The user is expected to have a sense that they need to be careful when their values are quite large. But the better recommendation is that the user use floating point numbers, which as easy as typing `2.0^63`. Though not always exact, floating point values can represent a much bigger range values and are exact for a reasonably wide range of integer values.
The user is expected to have a sense that they need to be careful when their values are quite large. But the better recommendation is that the user use floating point numbers, which is as easy as typing `2.0^63`. Though not always exact, floating point values can represent a much bigger range values and are exact for a reasonably wide range of integer values.
::: {.callout-note}
@@ -600,7 +587,7 @@ The user is expected to have a sense that they need to be careful when their val
We can see in the following, using the smaller 8-bit type, what goes on internally with successive powers of `2`: the bit pattern is found by shifting the previous one over to the left, consistent with what happens at the bit level when multiplying by `2`:
```
```{julia}
[bitstring(Int8(2)^i) for i in 1:8]
```
@@ -1131,7 +1118,7 @@ val = 8/2*(2+2)
numericq(val)
```
Does this expression return the *correct* answer using proper order of operations?
Does this expression return the *correct* answer using the proper order of operations?
```{julia}
@@ -1189,8 +1176,8 @@ $$
Attempting to compute this, we have:
```{julia}
c = 299_792_458; # the speed of light
G = 6.67430e-11; # Gravitational constant
c = 299_792_458; # the speed of light
G = 6.67430e-11; # Gravitational constant
h = 6.62607015e-34; # Planck's constant
h_bar = h / (2*pi);
planck_length = sqrt(h_bar * G / c^3)
@@ -1209,3 +1196,40 @@ Yes, this is computed incorrectly. The value `c^3` *overflows* as the actual val
"""
buttonq(choices, 3; explanation=explanation)
```
## Appendix
The order of operations for common operators are summarized in `Julia`'s [manual](https://docs.julialang.org/en/v1/manual/mathematical-operations/) in the "Operator Precedence and Associativity" section. @tbl-precedence-associativity is an edited version of one presented there.
::: {#tbl-precedence-associativity}
| Category | Operators | Associativity |
|:---------------|:--------------------------------|:---------------|
|Syntax | `.` followed by `::` | Left |
|*Exponentiation*| `^` | Right |
|Unary | `+`, `-` `!`, `~`, `√` | Right |
|Bit shifts | `<<`, `>>`, `>>>` | Left |
|Fractions | `//` | Left |
|*Multiplication*| `*`, `/`, `%`, `÷`, `&` | Left |
|*Addition* | `+`,`-`, `|` | Left |
|Syntax | `:`, `..` | Left |
|Syntax | `|>` | Right |
|Comparisons | `<|`, `>`, `<`, `>=`, `<=`, `==`, `===`, `!=`, `!--` | Non-associative |
|Control flow | `&&` followed by `||` followed by `?` | Right |
|Pair | `=>` | Right |
|Assignment | `=` `+-`, `-=`, `*=`, `/= | Right |
: Table highlighting the precedence and associativity of different types of operators. Adapted from the Julia manual.
:::
Parentheses force evaluation, so aren't listed in the table. Otherwise we highlighted `⋅EM⋅A⋅` with italics. The `DS` are in the list of operators.
The low precedence of the comparison, pair, and assignment operators ensure the left and right hand sides are parsed and evaluated before these binary operations, reducing the number of necessary parentheses.
The low precedence of `?` is helpful. This symbol is used in the `ternary` operation and this low precedence requires fewer parentheses for most uses.
The high precedence of the **unary** operations allows natural syntax for powers, where `2^-3` evaluates `-3` and then takes the power. However, note `2^1/2` will first find `2^1` and then divide by `2`.
The code that defines the order is in [Julia Syntax](https://github.com/JuliaLang/JuliaSyntax.jl/blob/main/src/julia/kinds.jl). A perusal will show that there are **numerous** unicode operations not listed in the @tbl-precedence-associativity above.