# What are Math Functions in CSS?

CSS, or Cascading Style Sheets, is a language used to style web pages. It allows you to control the look and feel of a website, including its layout, colors, and typography. One of the lesser-known features of CSS is its ability to perform mathematical calculations using functions. In this blog, we'll explore what math functions are in CSS, how to use them, and some practical examples to make your styling more dynamic and flexible.

## What are Math Functions in CSS?

Math functions in CSS are a set of predefined functions that allow you to perform calculations directly in your CSS code. These functions can be used to manipulate numerical values, such as lengths, percentages, and angles. Some common use cases for math functions in CSS include creating responsive designs, calculating sizes and positions, and animating elements.

Here are some of the most commonly used math functions in CSS:

• `calc()`: Performs a basic arithmetic operation on one or more values.
• `min()`: Returns the minimum value from a list of values.
• `max()`: Returns the maximum value from a list of values.
• `clamp()`: Clamps a value between a minimum and maximum value.

Now that we know what math functions are in CSS let's dive into how to use them.

## Using `calc()`

The `calc()` function is the most versatile math function in CSS. It allows you to perform addition, subtraction, multiplication, and division on one or more values.

Here's the basic syntax for the `calc()` function:

``````property: calc(expression);
``````

Let's look at a simple example. Suppose you want to create a responsive design where the width of an element should be 50% of the viewport width, plus 20 pixels. You can use the `calc()` function to achieve this:

``````.element {
width: calc(50% + 20px);
}
``````

In this example, the `calc()` function calculates the width of the element by adding 50% of the viewport width and 20 pixels. The result is a width that automatically adjusts based on the viewport size, making the design responsive.

You can also use the `calc()` function to perform more complex calculations, such as the following example, which calculates the height of an element based on its width:

``````.element {
height: calc(100px + 2 * (100% - 100px));
}
``````

In this case, the `calc()` function calculates the height by adding 100 pixels to twice the difference between 100% and 100 pixels. This expression ensures that the height of the element increases as the width increases, creating a dynamic layout.

## Using `min()` and `max()`

The `min()` and `max()` functions return the minimum and maximum values from a list of values, respectively. These functions can be helpful when you want to set limits on the size of an element or create responsive designs that adapt to different screen sizes.

Here's the basic syntax for the `min()` and `max()` functions:

``````property: min(value1, value2, ...);
property: max(value1, value2, ...);
``````

For example, let's say you want to set a minimum and maximum font size for a heading element. You can use the `min()` and `max()` functions to achieve this:

``````.heading {
font-size: min(24px, 4vw);
font-size: max(16px, 2vw);
}
``````

In this example, the `min()` function ensures that the font size of the heading is never smaller than 24 pixels or 4% of the viewport width, whichever is smaller. The `max()` function ensures that the font size is never larger than 16 pixels or 2% of the viewport width, whichever is larger. This allows the font size to adapt to different screen sizes while maintaining a readable size.

## Using `clamp()`

The `clamp()` function is a combination of the `min()` and `max()` functions. It clamps a value between a minimum and maximum value, making it useful for setting limits on properties such as font sizes, widths, and heights.

Here's the basic syntax for the `clamp()` function:

``````property: clamp(min_value, value, max_value);
``````

For example, let's say you want to create a responsive design where the width of an element is at least 300 pixels, at most 800 pixels, and 50% of the viewport width. You can use the `clamp()` function to achieve this:

``````.element {
width: clamp(300px, 50%, 800px);
}
``````

In this example, the `clamp()` function ensures that the width of the element is never smaller than 300 pixels, never larger than 800 pixels, and always 50% of the viewport width within those limits. This creates a flexible design that adapts to different screen sizes while maintaining a minimum and maximum width.

## Practical Examples

Now that we've explored the different math functions in CSS, let's look at some practical examples that demonstrate their usefulness in real-world scenarios.

### Example 1: Responsive Font Size

In this example, we'll use the `clamp()` function to create a responsive font size that adapts to different screen sizes while maintaining a minimum and maximum size.

``````body {
font-size: clamp(16px, 4vw, 24px);
}
``````

In this case, the `clamp()` function ensures that the font size is never smaller than 16 pixels, never larger than 24 pixels, and always 4% of the viewport width within those limits. This creates a readable font size that adapts to different screen sizes.

### Example 2: Equal Height Columns

In this example, we'll use the `calc()` function to create equal-height columns in a two-column layout. The left column has a fixed width of 300 pixels, and the right column should fill the remaining space.

``````<div class="container">
<div class="left-column"></div>
<div class="right-column"></div>
</div>
``````
``````.container {
display: flex;
}

.left-column {
width: 300px;
}

.right-column {
width: calc(100% - 300px);
}
``````

In this case, the `calc()` function calculates the width of the right column by subtracting 300 pixels from 100%. This ensures that the right column fills the remaining space and creates a two-column layout with equal-height columns.

### Example 3: Aspect Ratio

In this example, we'll use the `calc()` function to create a responsive aspect ratio for a video or image element.

``````<div class="aspect-ratio">
<img src="image.jpg" alt="Image with aspect ratio" />
</div>
``````
``````.aspect-ratio {
position: relative;
width: 100%;
height: 0;
padding-bottom: calc(9 / 16 * 100%);
}

.aspect-ratio img {
position: absolute;
top: 0;
left: 0;
width: 100%;
height: 100%;
}
``````

In this case, the `calc()` function calculates the padding-bottom of the `.aspect-ratio` element by dividing 9 by 16 and multiplying by 100%. This creates a 16:9 aspect ratio that resizes based on the width of the element, maintaining the correct proportions for the image or video.

## Conclusion

Math functions in CSS provide powerful tools for creating dynamic and responsive designs. By understanding and using `calc()`, `min()`, `max()`, and `clamp()` functions, you can create more flexible and adaptable layouts that look great on any screen size. So the next time you're working on a CSS project, consider incorporating math functions to make your styling more efficient and responsive.

## Learn to code in our 100% online programs

Altcademy coding bootcamp offers beginner-friendly, online programs designed by industry experts to help you become a coder. 85%+ of Altcademy alumni are hired within 6 months after graduation. See how we teach, or click on one of the following programs to find out more.