How To Write A Piecewise Function In Desmos

Desmos is a powerful, free online graphing calculator that's beloved by students and educators alike. One of its many useful features is the ability to define and graph piecewise functions. Piecewise functions, as the name suggests, are functions defined by multiple sub-functions, each applying to a certain interval of the input variable. Mastering how to write these in Desmos opens up a world of mathematical exploration.

Understanding Piecewise Functions

Before diving into Desmos, let's solidify our understanding of piecewise functions. They're a way to represent functions that behave differently depending on the input value. Think of them as a collection of different rules, each with its own domain.

A typical piecewise function looks something like this:

f(x) = {
  x^2,     if x < 0
  2x + 1,  if 0 <= x <= 2
  3,       if x > 2
}

In this example:

• For any x less than 0, the function is defined as x².
• For any x between 0 and 2 (inclusive), the function is defined as 2x + 1.
• For any x greater than 2, the function is a constant, 3.

Why are Piecewise Functions Important?

They are crucial for modeling real-world situations where behavior changes abruptly. Examples include:

• Tax brackets: The amount of income tax you pay depends on which income bracket you fall into.
• Shipping costs: The shipping fee might be a fixed amount up to a certain weight, then increase per pound beyond that.
• Step functions: These are used in computer science and engineering to represent digital signals.
• Absolute value functions: Although Desmos has a built-in absolute value function, it is a piecewise function itself!

Writing Piecewise Functions in Desmos: The Basics

Desmos uses a simple and intuitive syntax for defining piecewise functions. The general structure is:

f(x) = {condition: expression, condition: expression, ...}

Let's break this down:

• f(x): This is how you define the function, just like you would with any other function in Desmos. You can use any valid function name (e.g., g(x), h(x), y(x)).
• {}: These curly braces enclose the different pieces of the function.
• condition: This is a Boolean expression (an expression that evaluates to true or false) that defines the interval for which the corresponding expression applies. Conditions typically involve inequalities.
• expression: This is the mathematical expression that defines the function's value within the specified interval.
• ,: Commas separate each piece of the function.

Example: Implementing the Function from Earlier

Let's translate the piecewise function from our earlier example into Desmos syntax:

f(x) = {x < 0: x^2, 0 <= x <= 2: 2x + 1, x > 2: 3}

Simply type this directly into a new expression line in Desmos. Desmos will automatically graph the piecewise function.

Explanation:

• x < 0: x^2: If x is less than 0, the function's value is x².
• 0 <= x <= 2: 2x + 1: If x is greater than or equal to 0 AND less than or equal to 2, the function's value is 2x + 1. Note how we combine two inequalities.
• x > 2: 3: If x is greater than 2, the function's value is 3.

Refining Your Piecewise Functions in Desmos

Now that you have the basics down, let's look at some techniques to make your piecewise functions more robust and visually appealing in Desmos.

1. Using Different Inequality Symbols:

Desmos supports all the standard inequality symbols:

• <: Less than
• >: Greater than
• <=: Less than or equal to
• >=: Greater than or equal to

Careful use of these symbols is crucial for defining the intervals correctly. Remember the difference between inclusive (including the endpoint) and exclusive (excluding the endpoint) intervals.

Example:

To define a function that is x when x is strictly less than 5, and x² when x is greater than or equal to 5, you would use:

f(x) = {x < 5: x, x >= 5: x^2}

2. Combining Inequalities:

As seen in the previous example, you can combine inequalities using the following syntax:

a <= x <= b (This means a is less than or equal to x, AND x is less than or equal to b).

This is essential for defining intervals that are bounded on both sides.

3. Handling Discontinuities:

Piecewise functions often have discontinuities, which are points where the function "jumps" or is undefined. Desmos generally handles discontinuities gracefully, but you might want to emphasize them visually.

• Open Circles: To indicate that a point is not included in a particular piece of the function, you can use different inequality signs. For instance, if a function is x for x < 2, but undefined at x = 2, the graph will have an open circle at (2, 2).
• Strategic Use of Inequalities: Carefully choose whether to use < or <= (and > or >=) to control which pieces of the function include the endpoints.

4. Color-Coding and Styling:

Desmos allows you to customize the appearance of your graphs. You can change the color and thickness of each piece of the piecewise function to make it easier to distinguish the different segments.

• Click the Gear Icon: Next to the function definition in Desmos, click the gear icon (graph settings).
• Change the Color: Click on the colored circle to choose a new color.
• Adjust the Thickness: Use the slider to change the line thickness.
• Choose a Style: Select from different line styles (solid, dashed, dotted).

Color-coding is particularly useful for complex piecewise functions with many segments.

5. Using Variables for Conditions:

For more complex scenarios, you can define variables to represent parts of your conditions. This can make your expressions easier to read and modify.

Example:

a = 0
b = 5
f(x) = {x < a: x^2, a <= x <= b: 2x + 1, x > b: 3}

In this example, a and b are variables that define the boundaries of the intervals. You can easily change the values of a and b to adjust the function's behavior.

6. Defining Functions Within Functions:

You can even define other functions and then use them within your piecewise function. This is helpful for creating modular and reusable code.

Example:

g(x) = x^3 - 4x
f(x) = {x < 0: g(x), x >= 0: -g(x)}

Here, f(x) uses the function g(x) in its definition. This allows you to create more complex relationships between different parts of your graph.

7. Working with Absolute Value:

While Desmos has a built-in absolute value function (abs(x)), it's a great example of a piecewise function in disguise. The absolute value of x is x if x is positive or zero, and -x if x is negative. You can define it yourself as:

f(x) = {x >= 0: x, x < 0: -x}

This illustrates how even seemingly simple functions can be expressed as piecewise functions.

Advanced Applications of Piecewise Functions in Desmos

Once you're comfortable with the basics, you can explore more advanced applications of piecewise functions in Desmos.

1. Modeling Real-World Phenomena:

Piecewise functions are excellent for modeling situations where behavior changes abruptly. Consider these examples:

• A Ramp Function: A ramp function starts at zero and then increases linearly after a certain point. This can model things like the water level in a tank as it fills.

  h(t) = {t < 0: 0, t >= 0: 0.5t}
  

  This function represents a water level that is 0 for times less than 0, and increases at a rate of 0.5 units per time unit for times greater than or equal to 0.

• A Thermostat: A thermostat maintains a temperature within a certain range. If the temperature drops below a lower bound, the heater turns on. If the temperature rises above an upper bound, the air conditioner turns on. We can model this using a piecewise function (although a more complex model might involve differential equations).

  lowerBound = 68
  upperBound = 72
  temperature(t) = {temperature(t-1) < lowerBound: temperature(t-1) + 1, temperature(t-1) > upperBound: temperature(t-1) - 1, lowerBound <= temperature(t-1) <= upperBound: temperature(t-1)}
  

  This is a simplified model, and it uses recursion, which can be tricky in Desmos. It assumes that the temperature at the current time t depends on the temperature at the previous time t-1. If the temperature is too low, it increases by 1. If it's too high, it decreases by 1. Otherwise, it stays the same. You would need to initialize temperature(0) to a starting value.

2. Creating Custom Animations:

You can use piecewise functions in conjunction with sliders to create custom animations in Desmos. The slider value can control which piece of the function is active, creating the illusion of movement.

Example:

Let's say you want to animate a point moving along a line segment.

1. Create a Slider: In Desmos, create a slider named t with a range from 0 to 1.

2. Define the Endpoints: Define two points, A = (1, 2) and B = (5, 4).

3. Create the Piecewise Function:

   x(t) = {0 <= t <= 1: A.x + t*(B.x - A.x)}
   y(t) = {0 <= t <= 1: A.y + t*(B.y - A.y)}
   Point = (x(t), y(t))
   

   Here, x(t) and y(t) define the x and y coordinates of a point that moves linearly from point A to point B as t varies from 0 to 1. The Point expression creates the actual point that will be animated. As you move the slider t, the point will move along the line segment connecting A and B. The piecewise condition ensures the point only exists when the slider is within the specified range.

3. Building Mathematical Art:

Desmos is a fantastic tool for creating mathematical art, and piecewise functions are a key ingredient. By carefully crafting different pieces and combining them, you can create intricate and beautiful designs.

Example:

Creating a heart shape using piecewise functions is a classic Desmos example (though there are many ways to do it). Here's one approach:

f(x) = {x < -1: sqrt(1 - (abs(x) - 1)^2), -1 <= x <= 1: 2 - abs(x), x > 1: sqrt(1 - (abs(x) - 1)^2)}

This function combines a square root function and an absolute value function to create the characteristic heart shape. Experimenting with different functions and inequalities can lead to endless creative possibilities.

4. Defining Custom Activation Functions for Neural Networks (Illustrative):

While Desmos isn't directly used for training neural networks, you can illustrate the concept of activation functions, many of which are piecewise. Activation functions introduce non-linearity into neural networks, allowing them to learn complex patterns. Common examples include ReLU (Rectified Linear Unit) and Sigmoid (though Sigmoid isn't piecewise).

• ReLU (Rectified Linear Unit): This is a simple piecewise function that outputs the input directly if it's positive, and zero otherwise.

  relu(x) = {x > 0: x, x <= 0: 0}
  

• Leaky ReLU: A variation of ReLU that allows a small, non-zero gradient when the input is negative.

  alpha = 0.1  // Small positive constant
  leakyRelu(x) = {x > 0: x, x <= 0: alpha * x}
  

You can graph these activation functions in Desmos to visualize their behavior.

Troubleshooting Common Issues

Even with a good understanding of the syntax, you might encounter some issues when writing piecewise functions in Desmos. Here are some common problems and how to solve them:

• Function Not Defined: If Desmos says the function is not defined, double-check the spelling of the function name and make sure you've defined it correctly using f(x) = .... Also, ensure that all variables used within the function are properly defined.
• Graph Not Appearing: If you've entered the function correctly but the graph isn't showing up, check the following:
  • Zoom Level: The relevant part of the graph might be outside the current viewing window. Try zooming in or out, or using the "zoom fit" option.
  • Domain: Make sure the conditions cover the range of x values you're interested in. If there are gaps in the domain, the function will be undefined in those regions.
  • Typographical Errors: Carefully check for any typos in the function definition, especially in the inequality symbols and expressions.
• Unexpected Behavior: If the graph looks different from what you expect, review the conditions carefully. A common mistake is using the wrong inequality symbols (e.g., using < instead of <=). Also, double-check the expressions for each piece of the function.
• Domain Errors: Certain mathematical operations (like square roots and logarithms) are only defined for certain input values. If you use these operations in your piecewise function, make sure the conditions ensure that the inputs are valid. For example, sqrt(x) is only defined for x >= 0.

Conclusion

Writing piecewise functions in Desmos is a valuable skill for anyone interested in mathematics, science, or engineering. It allows you to model complex relationships, create custom animations, and explore the beauty of mathematical art. By understanding the basic syntax, mastering different inequality symbols, and refining your functions with color-coding and styling, you can unlock the full potential of Desmos as a powerful visualization tool. So, experiment, explore, and have fun creating your own piecewise functions! Remember to practice and don't be afraid to try new things. The more you use Desmos, the more comfortable you'll become with its features and the more you'll be able to create.