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!

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!

Desmos’ user interface. See the cursor? That’s where most of the magic happens!

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.

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 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.

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*}

Yep. It’s a full house. Just type in the trig functions using the above names!

So, what kinds of functions are supported in Desmos? Basically, any elementary function 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$).

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. 🙂

Derivative and Integral Functions. Line 2 and Line 3 refer to the same function by the way.

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:

The sign function. Note that Line 1 and Line 2 are equivalent.

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.

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:

Implicit functions and parametric equations — basically a bunch of conic sections!

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.

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:

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]$:

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:

A showcase of graph segmentation. Note that only the relevant variables can be used in the restriction clauses.

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:

Woah! What is this!?

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!

A figure with 10 quadratic functions. Not our fingerprint.

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!

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!

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.

Using the slider trick, we manage to nail down the root of the cubic function $x^3+x+1$ up to 6 decimals. Note that the root from the graph is only accurate up to 4 decimals.

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 to a new variable, subsequently using it for other fancier purposes such as building even more elaborate computations or graphicalizing the output of the computations into figures and animations.

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:

List definition, list transformation, simultaneous graphing and list-related computation.

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.

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:

A list of miscellaneous functions available from the Desmos keyboard menu

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 functions — 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.

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 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:

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 dummy 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!

Watch as Desmos performs some lightning-fast calculations your brain will never be able to!

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 please. By nesting one operator inside another, it becomes possible for us to evaluate complex mathematical expressions involving double summation, triple product and the like.

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!

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!

A showcase of triple integral, integral function and the First Fundamental Theorem of Calculus!

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!

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!

Point-plotting with a table. Note that the points are plotted for each of three functions simultaneously.

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 stylebetween 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.)

When you can manipulate the data by dragging the points, stats is fun. 🙂

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.

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., $\text{mean}([2.5,5.7,15,3]) $), or referred to via a variable name (e.g., $\text{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!

Visual statistics in action. 🙂

All in all, producing charts and diagram in @Desmos is more of an art than science! Click to Tweet

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 as subscripts on the variable as we please. 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 our original 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!

Regression in Desmos. Note that multivariate regression can still be performed — just not graphed.

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!

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.

The Graph Setting Menu in Desmos.

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)!

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.

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.

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!

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.

The Share Graph Menu in Desmos. Why not elect to have your graph considered for staff pick and see what happens? 😉

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!

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:

So there you have it! The end of another massive 8000-word module on a 21st-century embryonic-stage educational technology waiting to make its mark in the world of scientific computing. Now, is there more to this goodness? You bet! But we’re not saying much about it for now — unless perhaps if you opt in for that is! In the meantime, why not play around with Desmos a bit and show us what you’ve done in the comment section below? 🙂

Follow

About the Author

Math Vault and its Redditbots enjoy advocating for mathematical experience through digital publishing and the uncanny use of technologies. Check out their 10-principle learning manifesto so that you can be transformed into a fuller mathematical being too.

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.