Think you’re fond of of *graphing* and *computing* stuffs? Great! Because you might remember this thing called the **Texas Instrument TI-83** from the old days. Sure, while programmable calculators in general are still pretty much popular these days, the graphing calculators from the 21^{st}-century are also coming in waves as we speak â€” potentially disrupting the market of *scientific computing* and *educational technology*.

In particular, there’s a certain *education startup* out there, relentlessly seeking to hijack our *Internet browsers* and *mobile devices* into a â€” should we say â€” graphing extravaganza. And it comes with a funky name as well: **Desmos**.

Yep. You’ve heard it right. As *Greek-mythology-inspired* as it sounds, Desmos actually has nothing to do with the giant monster responsible for turning Mount Olympus into rubble through the wrath of infernal flames. Instead, it is probably better known as an innocent-looking math tool for the scientifically-minded, making applied math ever more palatable and entertaining!

Oh. Don’t believe in the* mighty power* of Desmos? Good job! Because it’ll then be our duty to beg to differ, and attempt to convince you otherwise. Indeed, if at the end of the module you still find the scope of Desmos’ functionalities *unappealing*, then â€” and only then â€” shall we concede defeat and return to our ivory tower for more advanced Buddhist meditation training! On the other hand, if you’re just way too lazy to read the 12-page **Desmos user manual**, and are looking for more *concrete examples* to kick-start the creative process, then this one is for you too!

## Graphing with Desmos

What is the single word people think of when they hear *online graphing calculator*? Graphing of course! Indeed, this is something that Desmos does incredibly well â€” despite having a user interface that appears to be deceptively simple. In what follows, we will see how to we can use Desmos to graph **equations**, **functions** and **inequalities** of different forms, before introducing some bonus features such as **graph segmentation**, **simultaneous graphing** and **animations**!

### Equations

When it comes to graphing, *equation* is one of those first words that comes to mind. On the other hand, it can also be construed as an *umbrella term* encompassing a plethora of mathematical objects such as **explicit functions**, **implicit functions**, **parametric equations** and **polar curves**. In what follows, we will illustrate how each of them can be graphed in Desmos â€” one step at a time.

#### Preliminaries

Before doing any graphing though, we need to first learn how to type out a few math symbols that are frequently sought for. To that end, we have provided a partial list of **common symbols** supported in Desmos â€” along with their *associated commands*:

- The
**Multiplication symbol**can be obtained by typing`*`

(`Shift`

+`8`

on US keyboards). - The
**Division line**can be obtained by typing`/`

(i.e., backslash). - $\pi$ can be obtained by typing
`pi`

, and $\theta$ by`theta`

. The same goes other**Greek Letters**such as $\alpha$, $\beta$, $\tau$ and $\phi$. - $\sqrt{}$ by
`sqrt`

, and $\sqrt[n]{}$ by`nthroot`

(after which the value of $n$ can be adjusted manually). - Use the key
`^`

(`Shift`

+`6`

on US keyboards) to create a**superscript**(e.g., $2$ in $x^2$), and the key`_`

(`Shift`

+`Hyphen`

on US keyboards) for a**subscript**(e.g., $1$ in $a_1$). - The
**ceiling function**by`ceil(), t`

he**floor function**by`floor()`

, and the**sign function**by`sign().`

- The
**absolute value symbol**by`|`

(i.e.,`Shift`

+`\`

on US keyboards).

For some commands (e.g., division, superscript, subscript), typing them out can move the cursor to the *upper* or *lower area*. In which case, you can use the **arrow keys** to help you navigate around the expression and type out what you want. Other times, you might need to use **parentheses** to group some of your expressions together â€” before they can be properly interpreted by Desmos.

#### Defining Functions

Traditionally, the most popular functions are the ones expressed in terms of $x$, which can be typed into a command line as follows:

\begin{align*} y = \text{some algebraic expressions in terms of }x \end{align*}

By reversing the roles of $x$ and $y$, functions in terms of $y$ can also be typed out into a command line as follows:

\begin{align*} x = \text{some algebraic expressions in terms of }y \end{align*}

So, what kinds of functions are supported in Desmos? Basically, all of the elementary functions you can think of! These include the 6 basic **trigonometric functions**, **exponential**/**logarithmic functions** (through the commands `exp`

, `ln`

and `log`

), **polynomials**, and **rational functions**. In addition, the 6 basic **inverse trigonometric functions** â€” along with the 6 basic **hyperbolic functions **â€” are readily supported by simply typing out the function’s name as well.

Now, if a function in terms of $x$ is meant to be referred on a repeated basis, then a **name** can be assigned to it by replacing the $y$ on the left-hand side with, say, $f(x)$. In a similar manner, a function in terms of $y$ can also be assigned a name as well, from which we can *define* and *name* a **compound function** in a command line â€” without having to resort to rewriting the expressions again and again:

- $y = 2f(3x-3)+e$
- $g(y) = \dfrac{\pi}{f(y)}$
- $f_1(x)= 55f(x)+43g(x) – 100 h(x)$

- $y = g(x)^2 \cdot \left( g(x)^{f(x)} \right)$
- $h(x) = 2 g(f(x)) + 3 g(f(x))$

And in case you’re wondering, the **polar functions** are equally supported in Desmos as well. However, do note that in this case, the functions will have to be typed out usingÂ $r$ and $\theta$ as the *designated variables*Â instead (e,g., $r=\frac{1}{2} \theta^2$).

#### Calculus-Related Functions

As it turns out, Desmos is remarkably receptive to *calculus-based expressions* as well. For example, once a function in terms of $x$ is given, by attaching $\dfrac{d}{dx}$ in front of it, the graph of its **derivative function** can be readily produced â€” without having to resort to the *explicit formula* of the derivative. Similarly, the derivative of a function in terms of $y$ can also be graphed by appending $\dfrac{d}{dy}$ in front of it. PrettyÂ neat, right?

Alternatively, if a function has already been assigned a name, we can alsoÂ use the **prime notation** to denote itsÂ derivative function (as in $f'(x)$). Apart from being easy to implement, the prime notationÂ also has the advantage ofÂ being able to refer toÂ *higher derivatives*Â by simply adding a few extra $’$ (e.g., $g”$), which â€”Â comparing toÂ the repeated use of $\dfrac{d}{dx}$ â€” is definitely a plus to have.

Of course, if Desmos is good with the derivative functions, thenÂ it shouldn’t a surprise that itÂ also supports theÂ **integral functions**Â as well. For the record, theÂ integral operator symbol $\int$ can be obtained by typing `int`

into the command line, afterÂ which you will have use the *arrow keys* to navigate around theÂ **lower/upper limits**Â and the **integrand**.

A note of caution though: when setting up an integral function â€”Â especially the ones involving *multiple* integral operatorsÂ â€”Â you want toÂ take that extra care to make sure that the *variable of integration*Â is different fromÂ the variable(s) in the limits. In doing so, you are in effect removing yourself from the need ofÂ *punching* Desmos for real, in caseÂ the expression doesn’tÂ turn out to be exactly *Desmos-interpretable*. ðŸ™‚

#### Piecewise Functions

To define a **piecewise function** in Desmos, weÂ canÂ use the following syntax on a command line:

\begin{align*} y \ (\text{or }x) = \{ \text{condition 1}: \text{definition 1}, \text{condition 2}: \text{definition 2}, \ldots \} \end{align*}

As with other functions, a piecewise function can also be given a name by simply replacing the *leftmost* variable with the name of the function. This way,Â we can recycle the function repeatedlyÂ without having to redefine it ever again.

For example, let’s say that we are interested in defining the function $f$ as the **sign function**. That is:

\begin{align*} f(x) = \begin{cases} -1 &Â x<0 \\ 0 & x=0 \\ 1 & x>0 \end{cases} \end{align*}

then this would be the expression we want to type into theÂ command line:

\begin{align*} f(x)=\left\{x<0:-1, x=0:0, x>0:1\right\} \end{align*}

which should produce the following figure:

In some occasions, it might be necessary to use the $\le$ andÂ $\ge$ symbols to define a function accurately. In which case, just know thatÂ the $\le$ symbol can be obtained by typing out `<`

and `=`

Â in that order, and theÂ $\ge$ symbol by typing out `>`

and `=`

Â , again in that order.

#### Other Equations

Since Desmos has its interface in **Cartesian coordinates** by default, it’s only natural that one wouldÂ use it to plotÂ equations expressed in terms of $x$ and $y$. In fact,Â **implicit functions** such asÂ that of a **circle**, anÂ **ellipse**Â or a **hyperbola**Â are all very good candidates for this.

However, what is less clear is that Desmos can also interpret **parametric equations**Â as well, provided that we type inÂ the equations for $x$ and $y$Â as if they wereÂ the coordinates of theÂ points instead (as inÂ $(2\cos t, 3 \sin t)$ ), and that the variable $t$ â€” the **designated variable** for parametric equations in Desmos â€” is used throughout the expression. For some reason, Desmos simply won’tÂ take anyÂ otherÂ variable such as $x$ or $\theta$ for thisÂ purpose.

On a more optimistic side, if you manage to type in aÂ parametric equation the rightÂ way, then you should be able see an inequality about the domain popping up right underneath the command line. Don’t take this for granted by the way, because this is whereÂ you get to configure the **range** of the variable $t$, which in essenceÂ determinesÂ the *portion* of the parametric equations that is actually displayed on the graph.

All right. So far so good?Â Here’s a figure illustratingÂ how implicit functions and parametric equations work out in Desmos:

### Inequalities

Think that wasÂ quite a list of equations already? Know this: *almost* all equations can be turned into **inequalities** by replacing the $=$ sign with $<$, $>$, $\le$ or $\ge$, thereby easilyÂ *doubling* the amount of graphs oneÂ can plot in Desmos. Â Just a caveat though: don’tÂ doÂ itÂ in a command line whereÂ *naming the function* is precisely the primary goal.

To get it started, here’s a list of inequalities you can tryÂ out andÂ get the juice flowing:

**Plane**: $y<2x$**Circle**: $x^2+y^2 \le 3^2$**Inside of a Polar Curve**: $r<3\cos ^2\theta$**Area Between Two Functions**Â (e.g., $f(x) \le y \le g(x)$)**SpaceÂ in Between Implicit Functions**: $2xy+y^2<4$

And here’s what happened when we throw inÂ these inequalities into Desmos.

which is pretty cool. And that’s just aÂ start!

### Graph Segmentation

When a valid equation/inequality is entered into a command line, Desmos will â€” by default â€” plot its graph by assuming the *full domain* under which the equation/inequality is satisfied. However, thisÂ doesn’t always yield the desired effects, and there are occasions where it’s preferable *not*Â to do so. In which case, one can always choose toÂ *segment* the graphÂ by imposing **restrictions** on theÂ equation/inequality in question â€” as long as the following syntax rule is being adhered to:

\begin{align*} \text{equation/inequality} \, \{ \text{condition 1}\}\{ \text{condition 2} \} \ldots Â \end{align*}

For example, to graph the function $x^2$ withÂ the domain restricted to only the *positive numbers*, the following line would do:

\begin{align*} y=x^2 \, \{ x>0 \} \end{align*}

Of course, the restriction could have been an inequality onÂ $y$ as well, as in the graph of the function $x^2$ where $y$ is restricted to the interval $[5,15]$:

\begin{align*} y=x^2 \, \{ 5 \le y \le 15 \} \end{align*}

or perhaps an inequality concerning both $x$ and $y$:

\begin{align*} y=x^2 \, \{ x+y<5 \}\{x>0\}Â \end{align*}

In fact, the restriction(s) could have been *any* number of equations/inequalities, involving *any*Â combination of theÂ *designated variables*Â (e.g., $x$, $y$, $r$, $\theta$), with theÂ caveatÂ being that the variables in the restrictions need to beÂ *compatible* with the equation/inequality they are restricting in the first place (e.g., a *polar equation*Â can only be restricted usingÂ theÂ *polar variables* $r$ and $\theta$).

Sounds a bit obscure? Here’s a picture for more info:

### Simultaneous Graphing

Tired of plotting very similar graphs *one by one*? Well, despairÂ not, for there is a way out when you’re with Desmos. Indeed, if an equation/inequality is expressed in terms of some parameter(s), which is itself definedÂ asÂ a **list** of multiple numbers, thenÂ multiple graphs can be created simultaneously for each of these numbers once and for all.

Hmm, what are we talking about here? Here’s an accompanying picture to help us out:

As you can see here, by defining a function with the **dummy parameter** $a$, which is itself defined as a *list* with the numbers $1$, $2$, $3$ and $4$, we were ableÂ to graph a total of four functions simultaneously with a mere two lines. Talk about laziness and efficiency!

AndÂ if you’re feeling a bit adventurous, you can certainly try entering an equation/inequality with *multiple parameters*, each of which isÂ defined as a list on its own with *equal sizes*. In fact, this “graphing-in-bulk” method has proved to be a formidable techniqueÂ inÂ drastically slowing down / paralyzing ourÂ computers andÂ mobile devices!

On a more serious note though, if you’re looking to exploit the functionalities of Desmos toÂ its fullest, this one is a must. Not only willÂ it *automate* a graphing process that would otherwise be annoyingly tedious toÂ carry out, but it also prevent us fromÂ reinventing the wheel when a template for the graphs isÂ already readily available. Oh, here comes another one!

### Animation with UndefinedÂ Parameters

When you enter a line of mathematical expression containing anÂ *undefined parameter*, Desmos will give you to option to include a **slider** for that parameter, which has the capability of allowingÂ you toÂ adjust ofÂ its value manually â€” or even better yet â€” create an **animation**Â out of it byÂ allowing the value of the parameter to increase/decrease *automatically*.

In particular, theÂ slider will allow you to control the **range**Â and the **increment size** of the parameter in question, along withÂ the **speed**Â and theÂ **direction** with which the parameter changes. And the reason why it matters, is becauseÂ by having sliders controlling the behaviors of our parameters of interest, it becomes possible for us to create various *animated objects* such asÂ *movable points*, *rotatingÂ equations*Â andÂ *animated regions/boundaries*.

For example, to modelÂ a particle moving along a *sine-waveÂ trajectory*, all we need to do is toÂ embed an *undefined parameter*Â intoÂ the coordinates of the sine waveÂ (as inÂ $(a, \sin 2\pi a)+3$ ), before activatingÂ the slider for the parameter usingÂ the **“play” button**. And if the point is meant to be moving along a *circular path* instead, putting an expression such as $(3\cos a – 5, 3\sin a + 6)$ into the command line would do.Â Furthermore,Â ifÂ the trajectory of a movable point actually defines a *function*, then Desmos will automatically make the pointÂ *draggable* across the $x$-axis, making it easier to manipulate than ever!

But then of course, movable points are just one of the many features animation has to offer.Â For example,Â if weÂ wish toÂ investigateÂ the contribution of the different parameters of a **depressed cubic equation**, then weÂ can do so by entering $y=x^3+ax^2+bx+c$ into the command line, beforeÂ activating the sliders for $a$, $b$ and $c$ in *any* combination we please.Â Actually, why notÂ toy around withÂ the sliders a bit first and observe how the shape of the graph changes during this process!

AndÂ if instead of having one function change its shape, you are interested in seeing several functions under a *common parameter* moving all at once, then you can â€” for exampleÂ â€” try typing outÂ $y=ax$, $y=ax^2$, $y=ax^3$ into three command lines, activate the slider, and watch as the polynomials move in tandem with pride!

## Computing with Desmos

While the interface of Desmos is primarily composed of aÂ *graphing grid* than anything else, the fact still remains that itÂ was built fundamentally for computing purpose â€” and will probably always be.Â In fact, weÂ will soon see that Desmos â€” while obviously well-equipped toÂ perform basic computations â€” can be *hijacked* into doingÂ a whole bunch of *non-graph-related* stuffs such as calculating aÂ **partial sum**, estimating theÂ **roots**Â of a function, determining the value of aÂ **definite integral**, or even finding theÂ **greatest common factors **fromÂ a list of integers!

### Elementary Calculations

In Desmos, any mathematical expression involving **addition**, **subtraction**, **multiplication** (`*`

), **division** (`/`

) and **exponentiation** (`^`

) can be put into a command line,Â so that ifÂ the expression entered contains no variable whatsoever, then the output can beÂ calculated and returned right back to you â€” usually in a blink of anÂ eye.

In addition, if some functions such as $f$ and $g$ were already being defined in the command lines and we wish to evaluate an expression involvingÂ theirÂ **function values** (e.g., $4f(15)+2g(0)+5$), then we are warranted to type in that same expression into a command line as well, after which Desmos would be more than happy to comply with our request. What’s more, by using the *prime notation*,Â we can even get DesmosÂ to evaluate the **derivative** of a function at a specific pointÂ (e.g., $f'(3)$).

By default, when an equation is entered into a command line, Desmos will give usÂ the option to display the **key points**Â (e.g., **intercepts**, **local maxima**, **local minima**) on the graph â€” whenever applicable. Furthermore, if weÂ choose to display these key points, then Desmos will give awayÂ the **coordinates** of these points for free as well â€” usually up to the firstÂ fourÂ decimal digits if weÂ just zoom in the graph.

Alternatively, if we are givenÂ a function $f$ and weÂ are interestedÂ in making a more accurate estimationÂ for the coordinates of aÂ key points (e.g., **root finding**), we can always try typing in $f(a)$ in a new line and activate the slider for $a$, which in turn allows usÂ to control the value of $a$ manually, and see its effect on $f$ in real-time. In fact, if we just configure the **step** of the slider to $10^{-6}$ (i.e., the *smallest* valid increment), then weÂ should be able score a few extraÂ decimals this way.

Furthermore, by naming the mathematical expression we want to compute, we can pass down the output of the computation into a new variable, subsequently using it for other fancier purposes such as building elaborate computations â€” or *graphicalizing* the outputÂ of the computations intoÂ *figures*Â and *animations*.

### Lists

When it comes to large-scale computations, it is sometimes more cost-efficient to take the time to constructÂ aÂ **list of numbers** first, than to manually write down the mathematical expressions one after another. In which case, just know that in Desmos, we can use theÂ **square-bracket keys** to createÂ a list, whose members could eitherÂ enumerated *explicitly*, or *implicitly* by typing three dots (as in $[7,8, \ldots ,22]$).

In fact, one can also create a list where the members are listed implicitly but with a non-trivial increment (as inÂ $[2,7, \ldots, 42]$), whereÂ the increment can be made to be as big as $5635$, or as small as $0.01$ â€” a flexibility which makesÂ Desmos a powerful tool for defining aÂ largeÂ set of numbers.

**Note**

In Desmos, the square-bracket keys are specifically conceived for the purpose ofÂ enumerating the members of a list.Â For delimiters whichÂ serve to group an algebraic expression together, use **parentheses** instead.

So why exactly do we even bother with creating a list?Â Because we can use it to run “bulk computations” forÂ *each* of the members in the list! And if we intend to use a list on a repeatedÂ basis,Â thenÂ we can choose to assign a *name* to the list,Â and pass the name down into theÂ command lines for even fancier purposes which include, among other:

- Performing aÂ
**transformation**Â on the list. *Simultaneously*graphing several functions of the same family.- Plotting a
**seriesÂ of points/line/mathematical objects**Â on the graph. - Calculating theÂ
**sum**of a list â€” or any other computation which depends on numerically manipulating the members in theÂ list.

All of which are exemplified in the figure below:

In some occasions, you might it easier to embed the *listing* and the *computations* into oneÂ single command line, but as the task complexityÂ grows, you might want to consider writing them down in several lines instead to improve legibility and facilitate future references.

### Computational Commands

In addition to the *standard features* offered by a scientificÂ calculator, Desmos has a bit of extra commands available to a typical programmable calculator as well. For example, we can use Desmos to compute the **greatest common factor**Â using the `gcd`

command â€” as long as we adhere to the following syntax:

\begin{align*} \gcd (\text{number 1}, \ldots, \text{number n}) \end{align*}

In a similar manner, we can also compute:

- The
**least common multiple**Â (through the`lcm`

command) - The
**minimum**of*multiple*numbers (through the`min`

command) - The
**maximum**Â (through the`max`

command) - The
**least positive residue**of $a$ under the modulus $b$ (by entering`mod(a,b)`

) - The number of
**combinations**available whenÂ choosing $r$ objects from $n$ objects (by entering`nCr(n,r)`

) - The number of
**permutations**Â when choosing $r$ objects from $n$ (by entering`nPr(n,r)`

) - The
**factorial**of $n$ (by entering`n!`

)

For example, if your grandpa offers you the chance of choosing 5 **giant gummy bears** from the 15 that he has to offer, thenÂ you can use Desmos to figure out how many ways you can choose the gummies by typingÂ `nCr(15,5)`

into a command line, and be delighted to find out that you actuallyÂ have $3003$ choices that youÂ can exercise freely. That is, $20+$ times more choices than gummies!

As for theÂ factorial, we’ve got an interesting fact for you:Â Desmos can calculateÂ the factorial of a number up to $170!$, which isÂ easily more than *double* of what can be achieved usingÂ a TI-83 â€” or any of itsÂ variants for that matter!

Actually, we are not quite done with the computational commands yet. Here’s five more interesting **unary operations**Â â€” for your pleasure:

`ceil()`

: The**ceiling function**. It allows you to return the ceiling of a number.`floor()`

: The**floor function**. It returns the floor of a number. Both ceil and floor are relevant in building theÂ**staircase functions**.`round()`

: The**rounding function**which rounds a number to an*integer*.`abs()`

: The**absolute value function**. Using the vertical bar keyÂ`|`

is preferred though.`sign()`

: The**sign function**discussed a bit earlier, which comes in handy in simplifying some obscure mathematical expressions.

### Series

If you look closely at the above figure with the Desmos keypad, you mightÂ notice something that looks like a **summation sign**, along with the **Pi product symbol** right next to it. Yep. That’s definitely something Desmos can handle for sure!

For example, let’s say that youÂ want to estimate the value of the infinite series $\displaystyle \frac{1}{1^2}+\frac{1}{2^2}+\cdots$, then one of the things you can do is to type something like this into the command line:

\begin{align*} \sum_{i=1}^{1000} \frac{1}{i^2} \end{align*}

For the record, the $\sum$ symbol can beÂ typed out using the `sum`

command, after which you will have to use the **arrow keys** to navigate around and specify the **lower/upperÂ limits**. By default, Desmos uses $n$ (instead of $i$, for example) as the main **index variable**, but you can always change it to another variable at your own discretion â€” as long as you choose a variable that is not pre-defined for other purposes.

Here, out of curiosity, we decided toÂ toyÂ around with the *upper limit* a bit, and found that Desmos seems to top out at $9,999,999$ â€” just one unit short $10$ millions. That’sÂ an astoundingÂ improvement from the age of *programmable calculators*!

And it gets even better: by using an *undefined parameter* as the upper limit and configuring the slider accordingly. we get toÂ turn the output of the computations into an *animation *â€” asÂ you can see in the figure on the left-hand side*.*Â Watch asÂ Desmos showcases itsÂ impressiveÂ number-crunching powerÂ in real-time!

Alternatively, weÂ can alsoÂ evaluate the product of a sequence using the `prod`

command, and â€” if needed â€” stack up as many summations and products as we like. By *nesting* one operator inside another, we can also evaluate **complexÂ mathematicalÂ expressions** such as those involving double summation or triple product â€” for instance.

In fact, with just a bit of imagination, we can evenÂ turn the result of computations into anÂ **animated graph**, by convertingÂ the numbers into an *animated line segment*, or â€” if we so prefer â€” convert the numbers into a comparative diagram of our liking!

What`s more, the `sum`

and `prod`

commands are not restricted to the computations of numbers either. For instance, we could try plotting out the $n$^{th}-degree **Taylor polynomials** of $\cos x$ by leavingÂ $n$ asÂ anÂ *undefined parameter*, so that once we turn on slider with $1$ as the *step-size*, we should start to see a bunch of functions flashingÂ like crazy!

### Definite Integrals

Looking to calculate the *area* below a strange-looking curve? StrugglingÂ to model the *total distance traveled* by an annoying fly? Or maybe you just want to project your *annual revenue* for the next year? Either way, the definite integral should have you covered!

In Desmos, the **integral symbol** $\int$ can be typed out using the `int`

command, after which you can use the *arrow keys* to navigate around and enter the **upper/lower limits**. Of course, when defining a definite integral, it’s necessary to include theÂ **differentialÂ **in such a way that the variable of the differential corresponds to the variableÂ in the function you wish toÂ integrate on.

Similar to the cases with theÂ *summation* and *product* operators, you are also free to stack up as many integral symbols as you like, and use Desmos to evaluate, say, Â a **double integral** (e.g., the *volume* of a geometrical figure) or even a **triple integral** (e.g., the *total mass* of a metal rod). But whichever the case, it’s always a good idea to get into the habitÂ ofÂ using parentheses judiciously, so that Desmos understands your expression correctly at each stage of the construction. Otherwise, it’s not our fault if Desmos refuses to parse your expressions like it’s crazy!

So what else can you do with the integral operator? For one,Â you can tryÂ mixing itÂ with summation and product operators, since they are after all the same kind of operator anyway. Alternatively, you can also use integrals to define an equation or an inequality (e.g., **integral function**), and do all kinds of stuffs with it such as verifying the **FirstÂ Fundamental Theorem of Calculus**!

## Statistics with Desmos

In addition to the standard graphing/computing features available to most graphing calculators, Desmos also has some neat, nativeÂ statistical featuresÂ for the analytically-driven, data-minded individuals. While it’s certainly no replacement for **specialized statistical softwares** such as R or SPSS, its capabilities in creating/manipulating **tables**, computing **statistical measures**Â and providing **regression models**Â should be more than enough toÂ cover the basics for the non-statisticians among us!

### Tables

While a **list** of data forms the basis of *univariate statistics*, having a **table** of data with multiple columns opens us to the whole new world of *multivariate statistics,*Â a branch of science which is becoming increasingly difficultÂ to ignore inÂ this day and age â€” whereÂ *big data* and *information mining* proliferates.

And while you’ll most likely *not* use Desmos for processing big data involving *giant tables* and *fancy metrics*, the fact remains you can still createÂ a table in DesmosÂ throughÂ the **“add item” menu**Â ($+$ sign in the upper-left corner), and enter the data manually as you see fit. Being primarily a *graphing calculator* in nature, Desmos seems to prefer presentingÂ a new table withÂ *two* humble columns by default: the first column $x_1$ presumably for the $x$-values, and the second column $x_2$ for the $y$-values.

Naturally, this setup wouldÂ lead to the use of table as a way of plotting **multipleÂ points**Â of a function, by first filling out a list ofÂ *input values* in the $x_1$ column, followed by *redefining the name* of the second column as a function of $x_1$ â€” so thatÂ Desmos can learn to automatically fill in the second column all on its own.

**Pro-Tip**

If you intend to haveÂ theÂ values under the *first* column to be equally spaced, but are too lazy to enter the values yourself manually, then you can auto-fill the first column by pressingÂ `Enter`

Â repeatedly â€” after entering the first two values into theÂ column.

In fact, by creating as many columns as we want, we can extend this *point-plotting feature* a bit toÂ three or four functions *simultaneously*, All we have to do is to make sure that “function columns” are labeledÂ as a function of $x_1$, and watch as Desmos auto-fills the rest of the table and graph for us. No need to ever redo the $x$-values over and over again!

Now, does that mean that you always have produce a table in Desmos from scratch? Not really. In fact, if you’re familiar any *spreadsheet software*, you couldÂ import the table to Desmos via a simple keyboard **copy-and-paste shortcut** (`Ctrl+C`

to copy, `Ctrl+V`

to paste). While for a small two-column table, importingÂ data can sometimes be an overkill.Â For a giant, multi-dimensional table with a dozen of variables, the copy-pasting shortcut can be a true life-saver.

By the way, did you notice the *circle icons* on the top of mostÂ columns? Not only are these icons created every time weÂ create a new column, but they are also our only gateway towardsÂ customizing the appearance of the points on the graph as well. By clicking on the *gear icon*Â followed by the relevantÂ *circle icon*, Desmos will give us the option toÂ change theÂ **color** of the points under the entire column. Alternatively, we can alsoÂ adjustÂ theÂ **graphing style**Â *between* the points here, by choosing to have eitherÂ *line segments* orÂ *curves*Â passing through themÂ â€” a feature which comes in handyÂ forÂ drawingÂ *figures* or makingÂ *polygon plots*.

To be sure, if you name a column as a *function* of another pre-existingÂ column, then the values underÂ the new column will be determined by those under the old column. However, if you choose to labelÂ the newÂ column as a **new variable**, then you are in effect making it possible for the entriesÂ under the column to assume *any* numerical value.

(for the record, a new variable doesn’t includeÂ any of the *pre-defined variables*Â such as $x$ and $y$.Â However, when you attach a new subscript to a pre-defined variable, it does become a new variable as a result.)

Moreover, for each of the columns that are labeled as a new variable, you can makeÂ the points underneath itÂ *draggable* throughÂ the **drag setting** (accessible again via the *gear* and *circleÂ icons*). By configuring the points so that they are either draggable in the *horizontal directions*, *vertical directions*, or in *every directions*, Â youÂ are essentially giving yourself the choice of manipulating the data *visually* â€” which in manyÂ cases is more effective thanÂ manipulating the data *numerically*.

### Descriptive Statistics

Every timeÂ we are givenÂ a collection ofÂ numbers â€” either in the form ofÂ a *list* or a *column*Â from aÂ table â€” weÂ can computeÂ some **statistical measures**Â based on them. Here’s a list of native, *unary* statistical commands supported in Desmos:

**Mean**: Use the`mean()`

commandÂ to obtain the*arithmetic mean*of a list of numbers, which can be defined*explicitly*(e.g., $\mathrm{mean}([2.5,5.7,15,3]) $), or referred to via a*variable name*(e.g., $\mathrm{mean}(a_1) $).**Median**: Use the`median()`

command to return the*middle number*(for a set with an*odd*number of data) or the*mean of the two middle numbers*(for a set with an*even*number of data).**Standard Deviation**: use the`stdev()`

command forÂ*sample standard deviation*, and`stdevp()`

Â for*population standard deviation*.**Mean Absolute Deviation**: use the`mad()`

command to find the*mean*of all*absolute deviations*of a list.**Variance**: use the`var()`

command to obtain the*sample variance*.**Total**: use the`total()`

command to find the*sum*of all numbers in the list.**Length**: use the`length()`

command to find out the*number of data*in the list.**Extrema**: use the`min()`

command for the*minimum*, and`max()`

for the*maximum*.

Additionally, here’s a list ofÂ *binary* statistical commands supported in Desmos, with slightly more delicate syntax:

**Quantile**: To obtain the $p$-quantile of a list $a$, type in`quantile(a,p)`

into a command line. Note that $p$ must be presented as a*decimal*between $0$ and $1$.**Covariance**: To obtain the*sample covariance*between the lists $a$Â andÂ $b$, type in`cov(a,b)`

or`cov(b.a)`

into a command line.**Correlation**: To obtain the*Pearson correlation coefficient*between the lists $a$ and $b$, type in`corr(a,b)`

or`corr(b,a)`

into a command line.

To be sure, the fact that these are about the only native commands supported in Desmos doesn’t mean that these are the only statistical measures we are restricted to. In fact, we could , for example, evaluate the **range** of a list $a$ by using the command `max(a) - min(a)`

,Â and calculate the **Inter-Quartile Range** by using `quantile(a,0.75) - quantile(a,0.25)`

.

In fact, with just a bit of imagination and ingenuity, it is possible to make out some **line charts** and **bar graphs**Â in Desmos as well. All that is required is some ability in drawing multipleÂ *vertical bars* and *line segments*Â â€” and perhaps the ability in doing so at the right spots as well. Here’s aÂ figure to keepÂ the idea of *data visualization* in the loop!

### Regression

When lookingÂ atÂ a seriesÂ of points and itsÂ associatedÂ **scatter plot**, it’s only natural that we seek to further understandÂ the nature of relationship â€” if any â€” between the two variables in question. In which case, it makes sense that we useÂ **regression models** to explain and predict the behaviors of one variable from another. In fact, if weÂ apply the “right” regression model to the data, weÂ can â€” more often than not â€”uncoverÂ surprising insights that would have been hardÂ to obtainÂ otherwise.

In Desmos, if you haveÂ a table with even just two columns â€” say $x_1$ and $y_1$ â€” thenÂ youÂ can createÂ a regression model for the associated points to your heart’s content. For a *linear* regression model, just type in $y_1 \sim mx_1 + b$ into a new line, and Desmos will be more than happy to provide a *best-fitting line* for you.Â For a *quadratic* model, you can type inÂ something along the line of $y_1 \sim a{x_1}^2+b x_1 + c$, and a parabolaÂ should be ready for you in a blink of anÂ eye. Additionally,Â if you prefer fittingÂ a **higher-degreeÂ polynomial** instead, or maybe you just find an**Â exponentialÂ **or a **logistic model**Â to be more appropriate,Â then you areÂ certainly welcome try out thoseÂ as well â€” as long as you followÂ the “regression syntax” outlined a bit above.

What’s more,Â while the graphing interface of Desmos is built primarily for *2D graphing*, that actually doesn’t deter us from doingÂ **multivariate regression**Â either. Indeed, if we are given aÂ giant table withÂ 4 columns â€” says $x_1$, $x_2$, $x_3$ and $y_1$ â€” then weÂ canÂ fitÂ a *linear model* for these variablesÂ by simplyÂ typing something along the line of $y_1 \simÂ ax_1+bx_2+cx_3 +d$ into the command line, so thatÂ even ifÂ Desmos is not properly equipped to plot graphs involving *multiple independent variables*, we can continue to run multivariate regression as if nothing happened in the first place!

**Pro-Tip**

While aÂ variable name usually takes the form ofÂ a *single letter* in Desmos, we are still free to use as much **subscripts** as we want to. For example, instead of using P as a variable for *population size*, we might just asÂ wellÂ use P_{opulation} instead, thereby eliminating the need of guessing what the variable stands for in the near future.

At the end of the day,Â whichever regression model weÂ choose, Desmos will always be glad to present us withÂ the **least-square line** for theÂ data, along its **parameters** (e.g., slope,Â intercept) and the **correlation**/$r^2$**Â **of the model. Additionally, we can also use the *grey “plot” button*Â (under “residuals” tag) to include the **residuals** into *both* the graph and the table â€” and if we are adventurous enough â€”Â pass on the residual variable into the command line again for more detailed analysis!

## Miscellaneous

All right. With most of the main features now settled, let’s move on to some other miscellaneous functionalities whichÂ you might find useful from time to time. In particular, we’ll see how to use Desmos to tweak around theÂ **graph setting**, create **notes**, organizing lines into **folders**, and make use ofÂ the **saving** and **sharing** functionalities!

### Graph Setting

If you look at the upper-right corner of Desmos’ user interface, you should be able to see an icon with a *wrench*Â on it. Why bothers? Because this is the place where you can have access to the **Graph Setting** menu, which contains a plethora of *global setting*Â that oneÂ can tweak around for practical and not-so-practical purposes*.*Â These include, among others:

- Toggling the grid from
**rectangular form**to**circular formÂ**â€” or disabling it entirely. - Labeling the $x$ and $y$-axes.
- Changing the
**step size**of each axis (e.g., using $\dfrac{\pi}{2}$ as step-size when graphing*trigonometricÂ functions*). - Interpreting the angles in either
**degree**or**radian**.

In addition, underneath the *wrench icon*, you should be able to see a $+$ and a $-$ icon. As one would expect, theseÂ icons are used forÂ **zooming in**Â andÂ **zooming out**Â the graph, respectively, and when either of the features is exercised, youÂ will see beneath the $-$ iconÂ an additional *home icon*, which allows you to return to the **default zoom level**. Think of it as some sort ofÂ *safety net* in case you blow up the graph out of proportion (literally)!

### Notes

A **note** is exactly that: a note for yourself and others looking atÂ yourÂ graph and command lines. To create a new note, click on theÂ commandÂ line where you want the note to appear, thenÂ type aÂ `"`

(i.e., the **double-quote symbol**) to turn the command line into a line for note. While admittedly a *non-computational*Â feature, a noteÂ can still be used to include anyÂ *comment*, *instruction* orÂ *explanations* deemed relevant to the graph and theÂ surrounding computations thereof. In fact, weÂ can even add a few *hyperlinks* here and there to spice up the discussion a bit. Just remember toÂ start the link with aÂ `http`

Â or `https`

prefix though.

### Collapsible/Expandable Folders

While primarilyÂ a cosmetic feature, a **folder** is integral tool for organizing your command lines into a coherent set of groups â€” the latter of which can *collapsed* or *expanded* upon demand. Similar to the case with a note, a folder can be created by first clicking on the command line where the folder should appear, and then by accessing the **Add Item menu**Â viaÂ the $+$ icon nearÂ the upper-left corner.Â Once aÂ folder is created, itÂ can be given a *label*, after which a command line can be dragged *in* or *out* of the folder with ease, and the *triangular arrow icon*Â next to it can be used to expand/collapse theÂ folder as one wishes.

### Images

WhileÂ graphical calculators are excellent tools for creating *geometrical figures*, there are certain times where anÂ image goes beyond simple geometry and needs to be imported from somewhere else instead. Fortunately, this is a feature wellÂ supported in Desmos, where anÂ image can be added to the graph the sameÂ way a folder is addedÂ toÂ a command line.

By default, Desmos likes to place an image so that its **center**Â is located at the *origin*, althoughÂ we can still move/resize the image by dragging along itsÂ *center* or the 8 *boundary points* surrounding it. In addition, an image’s **opacity** can be adjusted through the *Gear Icon*, and itsÂ **dimensional values** /Â **coordinates of the center**Â can also be configuredÂ *numerically*. Heck, we can evenÂ sneak inÂ some *undefined parameters*Â in them, therebyÂ turning a static image into a *flying picture*Â â€” where the dimension changes from one place to another!

### Saving / Sharing Graphs

FindÂ the mighty power of Desmos appealing and intend to use itÂ extensively in the near future? Then it makes sense that you create an account, and work on your graphsÂ *while logged into the account*. Why? Because then you can actually *save*Â these graphs for real, andÂ *share*Â them with other like-mindedÂ individuals!

In fact, working on a graph while logged in allows you to give a **title** to the graph, so that if you decide to save it for later, a simple `Ctrl + S`

will do. On the other hand, any saved graph can also be *deleted* â€” if needed to â€” by hitting the $\displaystyle \times$ button next toÂ the name of the graph to be deleted.

And if you’re feeling generous enough, you can always share your workÂ with others by generating a *link* for the graph â€” through the greenÂ **Share Graph icon** near the upper right corner. Remember, Desmos is a cloud-based application after all, which means that every time you save a graph and publish it somewhere online, you are in effect contributing to an ever-growing database ofÂ Desmos modulesÂ â€” all in the name of science and technology!

## Closing Words

Ouf! That’s quite a bit on an innocent-lookingÂ online graphing calculator isn’t it? By the way, if you’ve manage to make it this far, you are already a true hero on your way toÂ becoming a power user of Desmos! At the end of the day, whether you decide to use Desmos forÂ *graphing*, *computing*, *statistics* or *other purposes*, theÂ hope is that you would find a way toÂ leverage theseÂ functionalities and adapt them to your own needs. Who knows, maybe you can even turn some of yourÂ inspiration into aÂ fruitful, creative process â€” with perhaps a bit of *technical twist* along the way!

All right.Â Ready for the recap? Here’s aÂ jam-packedÂ *interactive table* on what we’ve covered thus far:

###### Preliminaries

Multiplication |

Division |

Greek Letters ($\pi, \theta, \alpha, \beta$) |

Roots ($\sqrt{}, \sqrt[n]{x}$) |

Superscript |

Subscript |

Ceiling Function |

Floor Function |

Sign Function |

Absolute Value |

Arrow Keys |

Parentheses |

###### Defining Functions

Functions (in terms of $x$) |

Functions (in terms of $y$) |

Trig Functions |

Exponential Functions |

Logarithmic Functions |

Polynomial Functions |

Rational Functions |

Inverse Trig Functions |

Hyperbolic Functions |

Function Naming |

Compounding Functions (via $+$, $-$,$\times$, $\div$, $\hat{}$ and $\circ $) |

Polar Functions |

###### Calculus-Related Functions

Derivative Operator |

Prime Notation |

Integral Operator |

Lower/Upper Limits (Integral) |

Integrand |

###### Piecewise Functions

Syntax (Piecewise Functions) |

Naming a Piecewise Functions |

Sign Function |

$\le, \ge$ Symbols |

###### Other Equations

Cartesian Coordinates |

Implicit Equations (e.g., circle, ellipse, hyperbola) |

Parametric Equations |

Designated Variable |

Adjusting the Domain (Parametric Equations) |

Planes |

Circles (Inside or Outside) |

Polar Curves (Inside or Outside) |

Area (between two functions) |

Space (in between the implicit functions) |

Restriction (Syntax) |

Restriction on $x$ |

Restriction on $y$ |

Restriction Involving Both $x$ and $y$ |

Restriction Involving Other Designated Variables |

List |

Dummy Parameter |

Using Multiple Parameters |

Undefined Parameter |

Slider |

Adjusting Range (Parameter) |

Increment Size (Parameter) |

Speed (Parameter) |

Direction (Parameter) |

“Play” Button (Slider) |

Movable Point |

Multiple Parameters (On a Command Line) |

Common Parameter (On Multiple Command Lines) |

Addition |

Subtraction |

Multiplication |

Division |

Exponentiation |

Function Values (Evaluation) |

Derivatives (Evaluation) |

Key Points (Intercepts, Local Maxima, Local Minima) |

Displaying Coordinates (Key Points) |

Root Finding (Using Slider) |

Naming Expressions |

Creating a List |

Explicit Enumeration |

Implicit Enumeration |

List Naming |

List Transformation |

Simultaneous Graphing (Using List) |

Plotting Multiple Mathematical Objects (Using List) |

List-Related Calculations |

Greatest Common Factor |

Least Common Multiple |

Minimum |

Maximum |

Least Positive Residue |

Combination (Counting) |

Permutation (Counting) |

Factorial |

Ceiling Function |

Floor Function |

Rounding Function |

Absolute Value Function |

Sign Function |

$\sum$ (Operator) |

$\prod$ (Operator) |

Arrow Keys (Navigation) |

Dummy Variable |

Upper/Lower Limits (Summation) |

Animating Series Calculation |

Nesting Operators |

Animated Graph (Series) |

Taylor Polynomial |

Integral Operator |

Upper/Lower Limits |

Differential |

Double/Triple Integrals |

Integral Function |

Table vs. List |

Creating a Table |

Plotting Multiple Points on a Function (Table) |

Creating Multiple Columns (Table) |

Importing Spreadsheet Data |

Adjusting Color (for Points in the Table) |

Graphing Style (Points in the Table) |

New Variable (as Column Name) |

Draggable Points |

Statistical Measures |

Mean |

Median |

Standard Deviations |

Mean Absolute Deviation |

Variance |

Total |

Length |

Minimum |

Maximum |

Quantile |

(Sample) Covariance |

Correlation |

Range |

Inter-Quartile Range |

Line Charts / Bar Graphs |

Scatter Plot |

Regression Model |

Linear Regression |

Quadratic Regression |

Higher-Polynomial Model |

Exponential Model |

Logistic Model |

Multivariate Regression |

Use of Subscripts (Variable Naming) |

Parameter (Least-Square Line) |

Correlation / $r^2$ (Least-Square Line) |

Residual (Least-Square Line) |

Grid Setting (Rectangular vs. Circular) |

Labeling Axes |

Configuring Step Size |

Angle Setting (Degree vs. Radian) |

Zoom In / Zoom Out |

Default Zoom Level |

Creating a Note (Keyboard Shortcut) |

Purpose (Note) |

Adding Hyperlinks |

Creating a Folder |

Naming a Folder |

Adding / Removing Lines from a Folder |

Expanding / Collapsing a Folder |

Importing an Image |

Adjusting Opacity |

Coordinates of the Center |

Dimensional Values |

Moving / Resizing Images (Visually vs. Numerically) |

Embedding Undefined Parameters |

Creating an Account |

Title (Graph) |

Saving a Graph |

Deleting a Graph |

Generate a Link for the Graph |

And with that, this definitive guide on Desmos has now come to an end. Of course, that doesn’t mean that it’s over yet â€” for there is yet another way to use Desmos which has great aesthetic and pedagogical value, and that is in the creation of **computational drawings**!

Yeah. It’s pretty cool. Figured out the one with the p-series. ðŸ™‚

Yep. You’ve got it. ðŸ™‚

As a middle-grade student, my knowledge is basic.

How can I add an x-intercept in Desmos? I need an x-intercept, but I only know how to do a y-intercept and Google is failing me. XD

Hi Rayray. There is no innate function for x-intercept for good reason â€” because a function or an equation can have 0 or multiple copies of them.

However, all is not lost though, as Desmos will display the coordinates of the x-intercepts if you click on them on the graph. The coordinates are up to a few decimal points of accuracy, and you can type them into the field if you want to.

Impressive way presenting Mathematical Ideas so that more & more of target group can grasp them

easily.

Thank you! Graphing and computing using Desmos is quite a topic all on its own, so we thought that keeping everything under one hood would make people life’s easier!

How can I get more than one decimal place for a slider? I tried to set the step to 0.01, but it does not work.

Hi Yif. It probably depends on how you’re using the parameter. You can adjust the size of step up to 0.000001 by clicking on the cog icon, and you might have to fill in the upper and lower bounds for that to happen.