Here are instructions on how to use Mathematica for Calculus I:

Introductory Instructions:

- Download Mathematica
- Basic Functions (note the capitalization of first letter)
- For e
^{x}use:`Exp[x]`

- For π use:
`Pi`

- For sin(x) use:
`Sin[x]`

– all other trigonometric functions are similar - For sin
^{–1}(x) use:`ArcSin[x]`

– all other trigonometric functions are similar - For | x | use:
`Abs[x]`

- For √x use:
`Sqrt[x]`

- For ∞ use:
`Infinity`

- For ln(x) use:
`Log[x]`

- For log
_{b}(x) use:`Log[b, x]`

- For ≤ use:
`<=`

- For ≥ use:
`>=`

- For sinh(x) use:
`Sinh[x]`

– all other hyperbolic functions are similar - For sinh
^{–1}(x) use:`ArcSinh[x]`

– all other inverse hyperbolic functions are similar

- For e
- To execute mathematica code
- Hold
`SHIFT`

key and press`ENTER`

- Hold

Algebra:

- Evaluate f(x) at x = a
- Define function using:
`f[x_] := expression`

, then use:`f[a]`

note: expression is any algebraic expression

note: After evaluating, you should clear the function using:`Clear[f]`

- Define function using:
- Evaluate f(x) at x = a
`expression /. x -> a`

note: expression is any algebraic expression

note: You can quickly evaluate the expression at several values of x using:`expression /. x -> {a1, a2, a3}`

[where a1, a2, a3, etc. are different x-values]

- Evaluate
`N[expression, d]`

note: expression is any expression to be evaluated

note: d is the number of digits needed in answer

- Define piecewise-defined function
- Define function using:
`f[x_] := Piecewise[{{function1, condition1},{function2, condition2}}, {x}]`

- Define function using:
- Plot a function
`Plot[expression, {x, xmin, xmax}]`

note: To change the y-values shown on the graph, use the additional argument:`PlotRange -> {ymin, ymax}`

note: To center the graph at the origin, use the additional argument:`AxesOrigin -> {0, 0}`

- Plot a function
- Define a function (see above), then use:
`Plot[f[x], {x, xmin, xmax}]`

- Define a function (see above), then use:
- Plot the real part of a radical function
`Plot[Sign[x]*Abs[x]^(1/n), {x, xmin, xmax}]`

note: 1/n is the n^{th}root function

- Plot multiple functions on same graph
`Plot[{expression1, expression2, expression3}, {x, xmin, xmax}]`

note: expression1, expression2, expression3, etc. are different functions

- Implicitly plot an equation
`ContourPlot[expression1 == expression2, {x, xmin, xmax}, {y, ymin, ymax}, AxesOrigin -> {0, 0}]`

note: the last two arguments may not be needed

- Factor/Simplify an expression
`Factor[expression]`

- Simplify an expression
`Simplify[expression, var]`

note: var is the independent variable`FullSimplify[expression, var]`

note: var is the independent variable

- Expand an expression
`Expand[expression]`

- Combine rational expressions
`Together[expression1 + expression2]`

note: You may have more than two rational expressions and can add or subtract the expressions

- Find real roots of polynomial equations
`Solve[polynomial == 0, x, Reals]`

note: For approximate solutions, use`NSolve[polynomial == 0, x, Reals]`

Precalculus:

- Expand a trigonometric expression
`TrigExpand[expression]`

- Find real roots of trignometric equation (if NSolve does not work)
- Plot function, then use:
`FindRoot[expression == 0, {x, xval}]`

note: xval is an x-value near the x-intercept of the function

- Plot function, then use:

Section 2.2:

- Evaluate bidirectional limits
`Limit[expression, var -> a]`

- Evaluate limits from left
`Limit[expression, var -> a, Direction -> 1]`

- Evaluate limits from right
`Limit[expression, var -> a, Direction -> -1]`

Section 2.5:

- Evaluate limits at infinity
`Limit[expression, var -> Infinity]`

Section 2.6:

- Find the derivative at a point x = a
- Define a function (see above), then use:
`Limit[(f[a + h] - f[a])/h, h -> 0]`

; OR - Define a function (see above), then use:
`f'[a]`

- Define a function (see above), then use:

Section 2.7:

- Find the derivative function
- Define a function (see above), then use:
`Limit[(f[x + h] - f[x])/h, h -> 0]`

; OR `D[function, var]`

note: var is the independent variable; OR- Define a function (see above), then use:
`f'[x]`

- Define a function (see above), then use:

Section 2.8:

- Multiple derivatives
`D[function, {var, n}]`

note: var is the independent variable and n is the n^{th}derivative; OR- Define a function (see above), then use:
`f''[x]`

note: use as many`'`

as needed

- Graph derivative functions
- Define a function (see above), then use:
`Plot[f'[x], {x, xmin, xmax}]`

note: you can graph any multiple derivative by using as many`'`

as needed

- Define a function (see above), then use:
- Find location(s) of local maximum(s) and local minimum(s)
- Define a function (see above), then use:
`NSolve[f'[x] == 0, x, Reals]`

- Define a function (see above), then use:
- Find location(s) of inflection point(s)
- Define a function (see above), then use:
`NSolve[f''[x] == 0, x, Reals]`

- Define a function (see above), then use:

Section 1.7:

- Find the parametric equations
`ParametricPlot[{x-function, y-function}, {t, tmin, tmax}]`

Section 3.5:

- Implicit differentiation
- Store the equation into the variable equation1:
`equation1 = expression1 == expression2`

, then`SHIFT-ENTER`

- Convert all y-variables into a function of x, i.e., y[x], and store into new variable:
`equation2 = equation1 /. y -> y[x]`

, then`SHIFT-ENTER`

- Differentiate each side of the equation and store into new variable:
`equation3 = D[equation2[[1]], x] == D[equation2[[2]], x]`

, then`SHIFT-ENTER`

- Solve the last equation for y'[x]:
`Solve[equation3, y'[x]]`

, then`SHIFT-ENTER`

- Store the equation into the variable equation1:

Section 4.5:

- l'Hôpital's Rule
- Define numerator function as f[x_] and denominator function as g[x_] (see above), then use:
`Limit[f'[x]/g'[x], x -> a]`

- Define numerator function as f[x_] and denominator function as g[x_] (see above), then use:

Section 4.7:

- Newton's Method
- Define function as f[x_] (see above)
- copy and paste the entire algorithm below, then
`SHIFT-ENTER`

:

recursiveNewton[f_, x_?NumberQ, previousX_: 0, tolerance_: (N[10^-20])] := If[Abs[x - previousX] > tolerance, Print[N[x, 20]]; recursiveNewton[f, N[x - f[x]/f'[x], 30], x, tolerance], x (*return result*)]

- then use:
`recursiveNewton[f, guess]`

note: where guess is an x-value near the root of the function

Section 4.8:

- Antiderivatives/Indefinite Integrals
- Define numerator function as f[x_] (see above), then use:
`Integrate[f[x], x]`

; OR `Integrate[expression, x]`

- Define numerator function as f[x_] (see above), then use:

Section 5.2

- Evaluating sums (e.g., sum of i from 1 to n)
`Sum[i, {i, 1, n}]`

- Evaluating Riemann sums
- Store integrand into f(x) using:
`f[x_]:=function`

- Store Δx into variable dx using:
`dx=(b-a)/n`

– where a is lower limit of integration and b is upper limit of integration - Find x
_{i}and store into variable xi using:`xi=expression`

- Evaluate the sum and store into sum variable:
`sum = Sum[f[xi]*dx,{i,1,n}]`

- Evaluate the limit of the sum as n → ∞:
`Limit[sum, n -> Infinity]`

- Store integrand into f(x) using:

Section 5.2 & 5.3:

- Evaluating definite integrals
- Define function as f[x_] (see above), then use:
`Integrate[f[x], {x, a, b}]`

note: where a is the lower limit of integration and b is the upper limit of integration; OR `Integrate[expression, {x, a, b}]`

note:`NIntegrate`

can be used to find an approximation of the definite integral

- Define function as f[x_] (see above), then use:

Section 5.4:

- Fundamental Theorem of Calculus, Part 1 (FTC1)
- Define function as f[t_] as function (see above), then use:
`D[Integrate[f[t], {t, 1, g(x)}], x]`

– where g(x) is some function of x

- Define function as f[t_] as function (see above), then use:

Still need to code:

- Graphing Riemann sums (Section 5.1)