Math#

Introduction#

Math includes both built-in Python functions and the full math module, which is automatically available in VEXcode GO. 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 your robot. You can also convert between degrees and radians, evaluate expressions, and work with special values like infinity and NaN.

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.

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.atan – Arctangent of a value in radians.

  • math.atan2 – Arctangent of y/x in radians, considering the quadrant.

  • math.asin – Arcsine of a value in radians.

  • math.acos – Arccosine of a value in radians.

  • math.degrees – Converts radians to degrees.

  • math.radians – Converts degrees to radians.

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 – Calculate the logarithm of x.

  • math.log10 – alculates the base-10 logarithm of x.

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

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

x

An integer or float.

 
def main():
    # Get the absolute value of -10
    abs_result = abs(-10)
    console.print(abs_result)
    console.new_line()

# abs_result = 10

# Start threads — Do not delete
start_thread(main)

round#

round rounds a number to a specified number of decimal places.

Usage:
round(x, ndigits)

Parameter

Description

x

An integer or float.

ndigits

Optional. The number of decimal places to round to. The default is 0.

 
def main():
    # Round 5.7 to the nearest integer
    round_int_result = round(5.7)
    console.print(round_int_result)
    console.new_line()

# round_int_result = 6

# Start threads — Do not delete
start_thread(main)


def main():
    # Round 3.14159 to 2 decimal places
    round_result = round(3.14159, 2)
    console.print(round_result)
    console.new_line()

# round_result = 3.14

# Start threads — Do not delete
start_thread(main)

min#

min returns the smallest value from multiple arguments or an iterable.

Usage:
min(arg1, arg2, …) or min(sequence)

Parameter

Description

arg1, arg2, …

The numbers to compare.

sequence

A list, tuple, or other sequence containing numbers.

 
def main():
    # Get the smallest number from 3, 7, and 1
    min_result = min(3, 7, 1)
    console.print(min_result)
    console.new_line()

# min_result = 1

# Start threads — Do not delete
start_thread(main)


def main():
    # Get the smallest value from a list
    min_list_result = min([10, 4, 25, 1])
    console.print(min_list_result)
    console.new_line()

# min_list_result = 1

# Start threads — Do not delete
start_thread(main)

max#

max returns the largest value from multiple arguments or an iterable.

Usage:
max(arg1, arg2, …) or max(sequence)

Parameter

Description

arg1, arg2, …

The numbers to compare.

sequence

A list, tuple, or other sequence containing numbers.

 
def main():
    # Get the largest number from 3, 7, and 1
    max_result = max(3, 7, 1)
    console.print(max_result)
    console.new_line()

# max_result = 7

# Start threads — Do not delete
start_thread(main)


def main():
    # Get the largest value from a list
    max_list_result = max([10, 4, 25, 1])
    console.print(max_list_result)
    console.new_line()

# max_list_result = 25

# Start threads — Do not delete
start_thread(main)

sum#

sum adds up all values in an iterable, with an optional starting value.

Usage:
sum(sequence, start)

Parameter

Description

sequence

A list, tuple, or other sequence containing numbers.

start

Optional. A value to add to the sum. Default is 0.

 
def main():
    # Calculate the sum of a list of numbers
    sum_result = sum([1, 2, 3, 4, 5])
    console.print(sum_result)
    console.new_line()

# sum_result = 15

# Start threads — Do not delete
start_thread(main)


def main():
    # Calculate the sum of a list with a starting value of 10
    sum_with_start = sum([1, 2, 3], 10)
    console.print(sum_with_start)
    console.new_line()

# sum_with_start = 16

# Start threads — Do not delete
start_thread(main)

divmod#

divmod returns a tuple containing the quotient and remainder of a division operation.

Usage:
divmod(a, b)

Parameter

Description

a

The dividend.

b

The divisor.

 
def main():
    # Perform integer division and remainder of 10 / 3
    divmod_result = divmod(10, 3)
    console.print(divmod_result)
    console.new_line()

# divmod_result = (3, 1)

# Start threads — Do not delete
start_thread(main)

pow#

pow raises a number to a power and optionally performs a modulus operation.

Usage:
pow(x, y, mod)

Parameter

Description

x

The base number.

y

The exponent.

mod

Optional. A modulus value. If provided, returns (x ** y) % mod.

 
def main():
    # Calculate 2 raised to the power of 3
    pow_result = pow(2, 3)
    console.print(pow_result)
    console.new_line()

# pow_result = 8

# Start threads — Do not delete
start_thread(main)

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

x

A number, string, or other object to convert.

base

Optional. The number base to use for conversion. Default is 10.

 
def main():
    # Convert a float to an integer to get rid of decimals
    price = 19.99
    price_int = int(price)
    console.print("{} coins".format(price_int))
    console.new_line()

# Output: 19 coins

# Start threads — Do not delete
start_thread(main)


def main():
    # Convert a string into an integer to use in calculations
    user_input = "55"
    user_number = int(user_input)
    console.print(user_number * 2)
    console.new_line()

# Output: 110

# Start threads — Do not delete
start_thread(main)

float#

float converts a number or string into a floating-point number.

Usage:
float(x)

Parameter

Description

x

A number, string, or other object to convert.

 
def main():
    # Convert division result to a float
    num_apples = 6
    num_people = 2
    apples_per_person = float(num_apples) / num_people
    console.print(apples_per_person)
    console.new_line()

# Output: 3.00

# Start threads — Do not delete
start_thread(main)


def main():
    # Convert a string into a float to use in calculations
    user_input = "23.4"
    user_number = float(user_input)
    console.print(user_number * 3)
    console.new_line()

# Output: 70.20

# Start threads — Do not delete
start_thread(main)

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

def main():
    # Calculate the area of a circle with radius 5 using pi
    circle_area = math.pi * 5 * 5
    console.print(circle_area)
    console.new_line()

# circle_area = 78.54

# Start threads — Do not delete
start_thread(main)

tau#

tau gives the value of 2π.

Usage:
math.tau

def main():
    # Calculate the circumference of a circle with radius
    circumference = math.tau * 5
    console.print(circumference)
    console.new_line()

# circumference = 31.42

# Start threads — Do not delete
start_thread(main)

e#

e gives the base of the natural logarithm.

Usage:
math.e

def main():
    # Calculate e raised to the power of 2
    e_power = math.pow(math.e, 2)
    console.print(e_power)
    console.new_line()

# e_power = 7.39

# Start threads — Do not delete
start_thread(main)

Trigonometry#

sin#

sin calculates the sine of an angle in radians and returns a float.

Usage:
math.sin(x)

Parameter

Description

x

A float or integer representing an angle in radians.

 
def main():
    # Calculate the sine of 
    # 30 degrees in radians
    result = math.sin(math.radians(30))
    console.print(result)
    console.new_line()

# result = 0.50

# Start threads — Do not delete
start_thread(main)

cos#

cos calculates the cosine of an angle in radians and returns a float.

Usage:
math.cos(x)

Parameter

Description

x

A float or integer representing an angle in radians.

 
def main():
    # Calculate the cosine of 
    # 60 degrees in radians
    result = math.cos(math.radians(60))
    console.print(result)
    console.new_line()

# result = 0.50

# Start threads — Do not delete
start_thread(main)

tan#

tan calculates the tangent of an angle in radians and returns a float.

Usage:
math.tan(x)

Parameter

Description

x

A float or integer representing an angle in radians.

 
def main():
    # Calculate the tangent of 
    # 45 degrees in radians
    result = math.tan(math.radians(45))
    console.print(result)
    console.new_line()

# result = 1.00

# Start threads — Do not delete
start_thread(main)

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

x

A float or integer between -1 and 1.

 
def main():
    # Calculate the arc sine 
    # of 0.5 in degrees
    result = math.degrees(math.asin(0.5))
    console.print(result)
    console.new_line()

# result = 30.00

# Start threads — Do not delete
start_thread(main)

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

x

A float or integer between -1 and 1.

 
def main():
    # Calculate the arc cosine 
    # of 0.5 in degrees
    result = math.degrees(math.acos(0.5))
    console.print(result)
    console.new_line()

# result = 60.00

# Start threads — Do not delete
start_thread(main)

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

x

A float or integer.

 
def main():
    # Calculate the arc tangent 
    # of 1 in degrees
    arc_tan = math.atan(1.0)
    result = math.degrees(arc_tan)
    console.print(result)
    console.new_line()

# result = 45.00

# Start threads — Do not delete
start_thread(main)

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

y

A float or integer representing the y-coordinate.

x

A float or integer representing the x-coordinate.

 
def main():
    # Calculate the inverse tangent 
    # of 1/1 in degrees
    atan2 = math.atan2(1.0, 1.0)
    result = math.degrees(atan2)
    console.print(result)
    console.new_line()

# result = 45.00

# Start threads — Do not delete
start_thread(main)

degrees#

degrees converts an angle from radians to degrees.

Usage:
math.degrees(x)

Parameter

Description

x

A float or integer representing an angle in radians.

 
def main():
    # Convert pi radians to degrees
    degrees_result = math.degrees(math.pi)
    console.print(degrees_result)
    console.new_line()

# degrees_result = 180.00

# Start threads — Do not delete
start_thread(main)

radians#

radians converts an angle from degrees to radians.

Usage:
math.radians(x)

Parameter

Description

x

A float or integer representing an angle in degrees.

 
def main():
    # Convert 180 degrees to radians
    radians_result = math.radians(180)
    console.print(radians_result)
    console.new_line()

# radians_result = 3.14

# Start threads — Do not delete
start_thread(main)

Rounding & Absolute Values#

ceil#

ceil rounds a number up to the nearest integer.

Usage:
math.ceil(x)

Parameter

Description

x

A float or integer to be rounded up.

 
def main():
    # Round 3.7 up to the nearest integer
    ceil_result = math.ceil(3.7)
    console.print(ceil_result)
    console.new_line()

# ceil_result = 4

# Start threads — Do not delete
start_thread(main)

floor#

floor rounds a number down to the nearest integer.

Usage:
math.floor(x)

Parameter

Description

x

A float or integer to be rounded down.

 
def main():
    # Round 3.7 down to the nearest integer
    floor_result = math.floor(3.7)
    console.print(floor_result)
    console.new_line()

# floor_result = 3

# Start threads — Do not delete
start_thread(main)

trunc#

trunc removes the decimal part of a number without rounding.

Usage:
math.trunc(x)

Parameter

Description

x

A float to be truncated.

 
def main():
    # Remove the decimal part of 3.7
    trunc_result = math.trunc(3.7)
    console.print(trunc_result)
    console.new_line()

# trunc_result = 3

# Start threads — Do not delete
start_thread(main)

fabs#

fabs returns the absolute value of a number as a float.

Usage:
math.fabs(x)

Parameter

Description

x

A float or integer.

 
def main():
    # Get the absolute value of -3.7
    fabs_result = math.fabs(-3.7)
    console.print(fabs_result)
    console.new_line()

# fabs_result = 3.70

# Start threads — Do not delete
start_thread(main)

Exponents & Logarithms#

log#

log calculates the logarithm of a number and returns a float.

Usage:
math.log(x, base)

Parameter

Description

x

A positive float or integer.

base

Optional. The logarithm base to use. By default this is the natural logarithm.

 
def main():
    # Calculate the natural logarithm
    # (base e) of 7.389056
    log_result = math.log(7.389056)
    console.print(log_result)
    console.new_line()

# log_result = 2

# Start threads — Do not delete
start_thread(main)


def main():
    # Calculate the log base 2 of 8
    log_result = math.log(8, 2)
    console.print(log_result)
    console.new_line()

# log_result = 3

# Start threads — Do not delete
start_thread(main)

log10#

log10 calculates the base-10 logarithm of a number and returns a float.

Usage:
math.log10(x)

Parameter

Description

x

A positive float or integer.

 
def main():
    # Calculate the base-10 logarithm of 100
    log10_result = math.log10(100)
    console.print(log10_result)
    console.new_line()

# log10_result = 2

# Start threads — Do not delete
start_thread(main)

pow#

pow raises x to the power of y and returns a float, even if both inputs are integers.

Usage:
math.pow(x, y)

Parameter

Description

x

A float or integer base.

y

A float or integer exponent.

 
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
console.print(power_result)
console.new_line()

# power_result = 8.00

sqrt#

sqrt calculates the square root of a number and returns a float, even for perfect squares.

Usage:
math.sqrt(x)

Parameter

Description

x

A non-negative float or integer.

 
def main():
    # Calculate 2 raised to the power of 3
    power_result = math.pow(2, 3)
    console.print(power_result)
    console.new_line()

# power_result = 8.00

# Start threads — Do not delete
start_thread(main)

exp#

exp calculates the exponential of a number and returns a float.

Usage:
math.exp(x)

Parameter

Description

x

A float or integer.

 
def main():
    # Calculate e raised to the power of 1
    exp_result = math.exp(1)
    console.print(exp_result)
    console.new_line()

# exp_result = 2.72

# Start threads — Do not delete
start_thread(main)

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

x

A float or integer to decompose.

 
def main():
    # Decompose 3.14159 into fractional and integer parts
    fractional_part, integer_part = math.modf(3.14159)
    console.print(fractional_part)
    console.new_line()
    console.print(integer_part)
    console.new_line()

# fractional_part = 0.14
# integer_part = 3.00

# Start threads — Do not delete
start_thread(main)

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

x

A float or integer to decompose.

 
def main():
    # Decompose 16 into its mantissa and exponent
    mantissa, exponent = math.frexp(16)
    console.print(mantissa)
    console.new_line()
    console.print(exponent)
    console.new_line()

# mantissa = 0.50
# exponent = 5

# Start threads — Do not delete
start_thread(main)

fmod#

fmod returns the remainder of division while keeping the sign of the dividend (x).

Usage:
math.fmod(x, y)

Parameter

Description

x

The dividend.

y

The divisor.

 
def main():
    # Calculate remainder of 10 / 3
    # that preserves the sign of 10
    fmod_result = math.fmod(10, 3)
    console.print(fmod_result)
    console.new_line()

# fmod_result = 1.00

# Start threads — Do not delete
start_thread(main)

copysign#

copysign returns x with the sign of y.

Usage:
math.copysign(x, y)

Parameter

Description

x

The value to modify.

y

The value whose sign will be copied.

 
def main():
    # Return -10 with the sign of 3 (positive)
    copysign_result = math.copysign(-10, 3)
    console.print(copysign_result)
    console.new_line()

# copysign_result = 10.00

# Start threads — Do not delete
start_thread(main)

ldexp#

ldexp computes x * (2 ** exp), which is equivalent to x * 2exp{code}.

Usage:
math.ldexp(x, exp)

Parameter

Description

x

The base value.

exp

The exponent.

 
def main():
    # Compute 3 * (2 ** 4)
    ldexp_result = math.ldexp(3, 4)
    console.print(ldexp_result)
    console.new_line()

# ldexp_result = 48.00

# Start threads — Do not delete
start_thread(main)
On this page