Math#
Introduction#
Math includes both built-in Python functions and the full math module, which is automatically available in VEXcode AIR. These tools allow you to perform everything from basic arithmetic to advanced trigonometry, rounding, and logarithmic operations.
Use these functions and constants to calculate positions, angles, distances, and other numeric values for the VEX AIR Drone Controller. You can also convert between degrees and radians, evaluate expressions, and work with special values like infinity and NaN.
Note: Except when explicitly noted otherwise, all return values are floats formatted to exactly five decimal places. Values with more than five decimal places are rounded, and values with fewer than five decimal places are extended with zeros so that exactly five decimal places are always displayed.
Below is a list of available math functions, constants, and utilities:
Built-in Functions – Common math tools included with Python.
abs – Returns the absolute value of a number.
round – Rounds a number to a specified number of decimal places.
min – Returns the smallest of the input values.
max – Returns the largest of the input values.
sum – Adds up all values in an iterable.
divmod – Returns the quotient and remainder as a tuple.
pow – Raises a number to a power, optionally with a modulus.
int – Converts a value to an integer.
float – Converts a value to a floating-point number.
Constants – Predefined values from the math module.
math.pi – The constant π (pi).
math.tau – The constant tau (2π).
math.e – Euler’s number, base of the natural log.
math.inf – Positive infinity.
math.nan – Not a Number (NaN).
Trigonometry – Calculate angles and relationships between sides.
math.sin – Sine of an angle in radians.
math.cos – Cosine of an angle in radians.
math.tan – Tangent of an angle in radians.
math.asin – Arcsine of a value in radians.
math.acos – Arccosine of a value in radians.
math.atan – Arctangent of a value in radians.
math.atan2 – Arctangent of y/x in radians, considering the quadrant.
math.degrees – Converts radians to degrees.
math.radians – Converts degrees to radians.
Hyperbolics – Advanced trig-related functions.
math.sinh – Hyperbolic sine of a value.
math.cosh – Hyperbolic cosine of a value.
math.tanh – Hyperbolic tangent of a value.
math.asinh – Inverse hyperbolic sine.
math.acosh – Inverse hyperbolic cosine.
math.atanh – Inverse hyperbolic tangent.
Rounding & Absolute Value – Adjust precision or direction.
math.ceil – Rounds up to the nearest integer.
math.floor – Rounds down to the nearest integer.
math.trunc – Removes the decimal portion.
math.fabs – Returns the absolute value as a float.
Exponents & Logarithms – Power, root, and log calculations.
math.pow – Raises a number to a power.
math.sqrt – Returns the square root.
math.exp – Calculates e to the power of x.
math.log – Natural logarithm (base e).
math.log10 – Base-10 logarithm.
math.log2 – Base-2 logarithm.
math.factorial – Factorial of an integer.
math.expm1 – More accurate result for
e^x - 1.
Floating Point Operations – Inspect or decompose float values.
math.modf – Returns the fractional and integer parts of a float.
math.frexp – Decomposes a number into mantissa and exponent.
math.fmod – Remainder with sign of the dividend.
math.copysign – Returns a value with the sign of another.
math.ldexp – Computes
x * (2 ** exp).
Comparison & Approximation – Check values with tolerances or categories.
math.isclose – Tests if two values are approximately equal.
math.isfinite – Checks if a number is finite.
math.isinf – Checks if a number is infinite.
math.isnan – Checks if a value is NaN.
Error & Gamma – Special mathematical functions.
math.gamma – Gamma function (generalized factorial).
math.lgamma – Logarithmic gamma.
math.erf – Error function.
math.erfc – Complementary error function.
Built-In Functions#
Python provides several built-in functions that allow you to perform mathematical operations inside your project.
abs#
abs returns the absolute value of a number, removing any negative sign.
Usage:
abs(x)
Parameter |
Description |
|---|---|
|
An integer or float. |
# Get the absolute value of -10
abs_result = abs(-10)
controller.screen.print(abs_result)
# abs_result = 10
round#
round returns a rounded a number to a specified number of decimal places as an integer.
Usage:
round(x, ndigits)
Parameter |
Description |
|---|---|
|
An integer or float. |
|
Optional. Controls how many decimal places to round to (between 0 and 5). The default is 0. When this parameter is used, |
# Round 5.7 to the nearest integer
round_int_result = round(5.7)
controller.screen.print(round_int_result)
# round_int_result = 6
# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
controller.screen.print(round_result)
# round_result = 3.14000
min#
min returns the smallest value from multiple arguments or an iterable.
Usage:
min(arg1, arg2, ...) or min(sequence)
Parameter |
Description |
|---|---|
|
The numbers to compare. |
|
A list, tuple, or other sequence containing numbers. |
# Get the smallest number from 3, 7, and 1
min_result = min(3, 7, 1)
controller.screen.print(min_result)
# min_result = 1
# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
controller.screen.print(min_list_result)
# min_list_result = 1
max#
max returns the largest value from multiple arguments or an iterable.
Usage:
max(arg1, arg2, ...) or max(sequence)
Parameter |
Description |
|---|---|
|
The numbers to compare. |
|
A list, tuple, or other sequence containing numbers. |
# Get the largest number from 3, 7, and 1
max_result = max(3, 7, 1)
controller.screen.print(max_result)
# max_result = 7
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
controller.screen.print(max_list_result)
# max_list_result = 25
sum#
sum adds up all values in an iterable, with an optional starting value.
Usage:
sum(sequence, start)
Parameter |
Description |
|---|---|
|
A list, tuple, or other sequence containing numbers. |
|
Optional. A value to add to the sum. Default is 0. |
# Calculate the sum of a list of numbers
sum_result = sum([1, 2, 3, 4, 5])
controller.screen.print(sum_result)
# sum_result = 15
# Calculate the sum of a list with a starting value of 10
sum_with_start = sum([1, 2, 3], 10)
controller.screen.print(sum_with_start)
# sum_with_start = 16
divmod#
divmod returns a tuple containing the quotient and remainder of a division operation.
Usage:
divmod(a, b)
Parameter |
Description |
|---|---|
|
The dividend. |
|
The divisor. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow returns a number raised to a power and optionally performs a modulus operation as an integer.
Usage:
pow(x, y, mod)
Parameter |
Description |
|---|---|
|
The base number. |
|
The exponent. |
|
Optional. A modulus value. If provided, returns |
# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
controller.screen.print(pow_result)
# pow_result = 8
# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
controller.screen.print(pow_mod_result)
# pow_mod_result = 6
int#
int converts a number or string into an integer. It also supports base conversion when converting from a string.
Usage:
int(x, base)
Parameter |
Description |
|---|---|
|
A number, string, or other object to convert. |
|
Optional. The number base to use for conversion. Default is 10. |
# Convert a float to an integer to get rid of decimals
price = 19.99
price_int = int(price)
controller.screen.print(f"{price_int} coins")
# Output: 19 coins
# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
controller.screen.print(user_number * 2)
# Output: 110
float#
float converts a number or string into a floating-point number.
Usage:
float(x)
Parameter |
Description |
|---|---|
|
A number, string, or other object to convert. |
# Convert division result to a float
num_apples = 6
num_people = 2
apples_per_person = float(num_apples) / num_people
controller.screen.print(apples_per_person)
# Output: 3.00000
# Convert a string into a float to use in calculations
user_input = "23.4"
user_number = float(user_input)
controller.screen.print(user_number * 3)
# Output: 70.20000
Math Module#
The math module in MicroPython provides additional methods for performing common mathematical calculations. These methods include trigonometric, logarithmic, and other numerical operations.
The math module is imported by default in VEXcode.
Constants#
Constants are predefined values that remain fixed during a project. They can be used in calculations without requiring any definition or assignment.
pi#
pi gives the mathematical constant π, the ratio of a circle’s circumference to its diameter.
Usage:
math.pi
# Calculate the area of a circle with radius 5 using pi
circle_area = math.pi * 5 * 5
controller.screen.print(circle_area)
# circle_area = 78.53982
tau#
tau gives the value of 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)
# circumference = 31.41593
e#
e gives the base of the natural logarithm.
Usage:
math.e
# Calculate e raised to the power of 2
e_power = math.pow(math.e, 2)
controller.screen.print(e_power)
# e_power = 7.38906
inf#
inf gives positive infinity as a float.
Usage:
math.inf
# Check if infinity is infinite
inf_value = math.inf
if math.isinf(inf_value):
controller.screen.print("Infinity")
# Prints "Infinity"
nan#
nan represents a special float for “Not a Number” (NaN).
Usage:
math.nan
# Check if nan is Not a Number
nan_value = math.nan
if math.isnan(nan_value):
controller.screen.print("Not a Number")
# Prints "Not a Number"
Trigonometry#
sin#
sin calculates the sine of an angle in radians and returns a float.
Usage:
math.sin(x)
Parameter |
Description |
|---|---|
|
A float or integer representing an angle in radians. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)
# sine_result = 0.50000
cos#
cos calculates the cosine of an angle in radians and returns a float.
Usage:
math.cos(x)
Parameter |
Description |
|---|---|
|
A float or integer representing an angle in radians. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
tan#
tan calculates the tangent of an angle in radians and returns a float.
Usage:
math.tan(x)
Parameter |
Description |
|---|---|
|
A float or integer representing an angle in radians. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)
# tangent_result = 1.00000
asin#
asin calculates the inverse sine (arc sine) of a number and returns a float representing the angle in radians.
Usage:
math.asin(x)
Parameter |
Description |
|---|---|
|
A float or integer between -1 and 1. |
# Calculate the arc sine of 0.5 in radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)
# arc_sine_result = 0.52360
acos#
acos calculates the inverse cosine (arc cosine) of a number and returns a float representing the angle in radians.
Usage:
math.acos(x)
Parameter |
Description |
|---|---|
|
A float or integer between -1 and 1. |
# Calculate the arc cosine of 0.5 in radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)
# arc_cosine_result = 1.04720
atan#
atan calculates the inverse tangent (arc tangent) of a number and returns a float representing the angle in radians.
Usage:
math.atan(x)
Parameter |
Description |
|---|---|
|
A float or integer. |
# Calculate the arc tangent of 1 in radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)
# arc_tangent_result = 0.78540
atan2#
atan2 calculates the principal value of the inverse tangent of y/x and returns a float representing the angle in radians.
Usage:
math.atan2(y, x)
Parameter |
Description |
|---|---|
|
A float or integer representing the y-coordinate. |
|
A float or integer representing the x-coordinate. |
# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 36.86990
degrees#
degrees converts an angle from radians to degrees.
Usage:
math.degrees(x)
Parameter |
Description |
|---|---|
|
A float or integer representing an angle in radians. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
radians#
radians converts an angle from degrees to radians.
Usage:
math.radians(x)
Parameter |
Description |
|---|---|
|
A float or integer representing an angle in degrees. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
controller.screen.print(radians_result)
# radians_result = 3.14159
Hyperbolics#
sinh#
sinh calculates the hyperbolic sine of x.
Usage:
math.sinh(x)
Parameter |
Description |
|---|---|
|
A float or integer representing the input value. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
cosh#
cosh calculates the hyperbolic cosine of x.
Usage:
math.cosh(x)
Parameter |
Description |
|---|---|
|
A float or integer representing the input value. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
tanh#
tanh calculates the hyperbolic tangent of x.
Usage:
math.tanh(x)
Parameter |
Description |
|---|---|
|
A float or integer representing the input value. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
asinh#
asinh calculates the inverse hyperbolic sine of x.
Usage:
math.asinh(x)
Parameter |
Description |
|---|---|
|
A float or integer representing the input value. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
acosh#
acosh calculates the inverse hyperbolic cosine of x.
Usage:
math.acosh(x)
Parameter |
Description |
|---|---|
|
A float or integer greater than or equal to 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
atanh#
atanh calculates the inverse hyperbolic tangent of x.
Usage:
math.atanh(x)
Parameter |
Description |
|---|---|
|
A float between -1 and 1 (exclusive). |
# Calculate the inverse hyperbolic tangent of 0.5
atanh_result = math.atanh(0.5)
controller.screen.print(atanh_result)
# atanh_result = 0.54931
Rounding & Absolute Values#
ceil#
ceil rounds a number up to the nearest integer.
Usage:
math.ceil(x)
Parameter |
Description |
|---|---|
|
A float or integer to be rounded up. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
controller.screen.print(ceil_result)
# ceil_result = 4
floor#
floor rounds a number down to the nearest integer.
Usage:
math.floor(x)
Parameter |
Description |
|---|---|
|
A float or integer to be rounded down. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
controller.screen.print(floor_result)
# floor_result = 3
trunc#
trunc removes the decimal part of a number without rounding.
Usage:
math.trunc(x)
Parameter |
Description |
|---|---|
|
A float to be truncated. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)
# trunc_result = 3
fabs#
fabs returns the absolute value of a number as a float.
Usage:
math.fabs(x)
Parameter |
Description |
|---|---|
|
A float or integer. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
controller.screen.print(fabs_result)
# fabs_result = 3.70
Exponents & Logarithms#
pow#
pow raises x to the power of y (xy) and returns a float.
Usage:
math.pow(x, y)
Parameter |
Description |
|---|---|
|
A float or integer base. |
|
A float or integer exponent. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
controller.screen.print(power_result)
# power_result = 8.00000
sqrt#
sqrt calculates the square root of a number and returns a float.
Usage:
math.sqrt(x)
Parameter |
Description |
|---|---|
|
A non-negative float or integer. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
exp#
exp returns e raised to the power of x (ex) and as a float.
Usage:
math.exp(x)
Parameter |
Description |
|---|---|
|
A float or integer. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)
# exp_result = 2.71828
log#
log calculates the natural logarithm of a number and returns a float.
Usage:
math.log(x)
Parameter |
Description |
|---|---|
|
A positive float or integer. |
# Calculate the natural logarithm (base e) of 7.389056
log_result = math.log(7.389056)
controller.screen.print(log_result)
# log_result = 2.00000
log10#
log10 calculates the base-10 logarithm of a number and returns a float.
Usage:
math.log10(x)
Parameter |
Description |
|---|---|
|
A positive float or integer. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)
# log10_result = 3.00000
log2#
log2 calculates the base-2 logarithm of a number and returns a float, even when x is a power of 2.
Usage:
math.log2(x)
Parameter |
Description |
|---|---|
|
A positive float or integer. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
controller.screen.print(log2_result)
# log2_result = 3.00000
factorial#
factorial returns the factorial of an integer x, which is the product of all positive integers up to x.
Usage:
math.factorial(x)
Parameter |
Description |
|---|---|
|
A non-negative integer. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 calculates e<sup>x</sup> - 1, which is more accurate for small x.
Usage:
math.expm1(x)
Parameter |
Description |
|---|---|
|
The exponent value. |
# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
Floating Point Operations#
modf#
modf decomposes a number into its fractional and integer parts and returns a tuple (fractional part, integer part), both as floats.
Usage:
math.modf(x)
Parameter |
Description |
|---|---|
|
A float or integer to decompose. |
# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)
# fractional_part = 0.14159
# integer_part = 3.00000
frexp#
frexp decomposes a number into its mantissa and exponent and returns a tuple (mantissa, exponent), where the mantissa is a float and the exponent is an integer.
Usage:
math.frexp(x)
Parameter |
Description |
|---|---|
|
A float or integer to decompose. |
# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)
# mantissa = 0.50000
# exponent = 5
fmod#
fmod returns the remainder of division while keeping the sign of the dividend (x).
Usage:
math.fmod(x, y)
Parameter |
Description |
|---|---|
|
The dividend. |
|
The divisor. |
# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
controller.screen.print(fmod_result)
# fmod_result = 1.00000
copysign#
copysign returns x with the sign of y.
Usage:
math.copysign(x, y)
Parameter |
Description |
|---|---|
|
The value to modify. |
|
The value whose sign will be copied. |
# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
controller.screen.print(copysign_result)
# copysign_result = 10.00000
ldexp#
ldexp computes x * (2 ** exp), which is equivalent to x * 2<sup>exp</sup>.
Usage:
math.ldexp(x, exp)
Parameter |
Description |
|---|---|
|
The base value. |
|
The exponent. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
isclose#
isclose checks if two numbers are approximately equal within a tolerance.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Parameter |
Description |
|---|---|
|
The first number to compare. |
|
The second number to compare. |
|
Optional. The maximum allowed difference between a and b, relative to their size. Default is 1e-09 (very small). |
|
Optional. A fixed margin of error, useful when comparing numbers close to zero. Default is 0.0. |
Note: If both rel_tol and abs_tol are provided, whichever condition is met first determines the result.
# Check if 1.000000001 and 1.0 are close
# within the default tolerance
isclose_result = math.isclose(1.000000001, 1.0)
controller.screen.print(isclose_result)
# isclose_result = True
# Check if 0.0000001 and 0.0 are close
# using absolute tolerance
isclose_result = math.isclose(0.0000001, 0.0, abs_tol=1e-07)
controller.screen.print(isclose_result)
# isclose_result = True
# Check if 1000000.0 and 1000000.1 are close
# with a stricter tolerance
isclose_result = math.isclose(1000000.0, 1000000.1, rel_tol=1e-10)
controller.screen.print(isclose_result)
# isclose_result = False
isfinite#
isfinite checks if a number is finite. This method returns a Boolean value:
True- The number is finite.False- The number is infinite.
Usage:
math.isfinite(x)
Parameter |
Description |
|---|---|
|
A float or integer to check. |
# Check if 42 is a finite number (returns True)
is_finite_true = math.isfinite(42)
controller.screen.print(is_finite_true)
# is_finite_true = True
# Check if infinity is a finite number (returns False)
is_finite_false = math.isfinite(math.inf)
controller.screen.print(is_finite_false)
# is_finite_false = False
isinf#
isinf checks if a number is infinite. This method returns a Boolean value:
True- The number is infinite.False- The number is finite.
Usage:
math.isinf(x)
Parameter |
Description |
|---|---|
|
A float or integer to check. |
# Check if infinity is an infinite number (returns True)
is_inf_true = math.isinf(math.inf)
controller.screen.print(is_inf_true)
# is_inf_true = True
# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
controller.screen.print(is_inf_false)
# is_inf_false = False
isnan#
isnan checks if a number is NaN (Not a Number). This method returns a Boolean value:
True- The number is NaN.False- The number is a valid number.
Usage:
math.isnan(x)
Parameter |
Description |
|---|---|
|
A float or integer to check. |
# Check if NaN (Not a Number) is NaN (returns True)
is_nan_true = math.isnan(math.nan)
controller.screen.print(is_nan_true)
# is_nan_true = True
# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
controller.screen.print(is_nan_false)
# is_nan_false = False
Error and Gamma Calculations#
gamma#
gamma computes the gamma function of x, which generalizes the factorial function for real and complex numbers. For an integer n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parameter |
Description |
|---|---|
|
A positive float or integer. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
lgamma#
lgamma computes the natural logarithm of the gamma function.
Usage:
math.lgamma(x)
Parameter |
Description |
|---|---|
|
A positive float or integer. |
# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
erf#
erf computes the error function of x.
Usage:
math.erf(x)
Parameter |
Description |
|---|---|
|
A float or integer representing the input value. |
# Calculate the error function of 1
erf_result = math.erf(1)
controller.screen.print(erf_result)
# erf_result = 0.84270
erfc#
erfc computes the complementary error function of x, which is defined as 1 - erf(x).
Usage:
math.erfc(x)
Parameter |
Description |
|---|---|
|
A float or integer representing the input value. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
controller.screen.print(erfc_result)
# erfc_result = 0.15730