Math#

Introduction #

The C++ standard library provides basic math functionality through <cmath>, which is supported in VEXcode IQ (2nd gen). These functions let you perform common mathematical operations such as trigonometry, rounding, exponentiation, and more.

Use them for calculating positions, angles, distances, or performing conversions between degrees and radians.

Below is a list of available math functions, constants, and utilities:

Common Math Functions – Common math tools.

abs – Returns the absolute value of a number.
fmin – Returns the smallest of the input values.
fmax – Returns the largest of the input values.
pow – Raises a number to a power.

Constants – Predefined values from <cmath>.

M_PI – The constant π (pi).
M_E – Euler’s number, base of the natural log.

Trigonometry – Calculate angles and relationships between sides.

sin – Sine of an angle in radians.
cos – Cosine of an angle in radians.
tan – Tangent of an angle in radians.
atan – Arctangent of a value in radians.
atan2 – Arctangent of y/x in radians, considering the quadrant.
asin – Arcsine of a value in radians.
acos – Arccosine of a value in radians.

Rounding & Absolute Value – Adjust precision or direction.

ceil – Rounds up to the nearest integer.
floor – Rounds down to the nearest integer.
trunc – Removes the decimal portion.

Exponents & Logarithms – Power, root, and log calculations.

sqrt – Returns the square root.
exp – Calculates e to the power of x.
log – Natural logarithm (base e).
log10 – Base-10 logarithm.

Floating Point Operations – Inspect or decompose float values.

fmod – Remainder with sign of the dividend.
copysign – Returns a value with the sign of another.

Common Math Functions #

abs #

abs returns the absolute value of a number, removing any negative sign.

Usage:
abs(x)

Parameter	Description
`x`	An integer or float.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Display the absolute value of -10
  Brain.Screen.print("%d", abs(-10));

  // Output: 10
}

fmin #

fmin returns the lower of two values as a float.

Usage:
fmin(value1, value2)

Parameter	Description
`value1`	The first value to compare.
`value2`	The second value to compare.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Display the lower of two values
  Brain.Screen.print("%f", fmin(7, 4));

  // Output: 4.000000
}

fmax #

fmax returns the higher of two values as a float.

Usage:
fmax(value1, value2)

Parameter	Description
`value1`	The first value to compare.
`value2`	The second value to compare.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Display the higher of two values
  Brain.Screen.print("%f", fmax(7, 4));

  // Output: 7.000000
}

pow #

pow returns a number raised to a power as a float.

Usage:
pow(base, exponent)

Parameter	Description
`base`	The base number.
`exponent`	The exponent.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Display the lower of two values
  Brain.Screen.print("%f", pow(2, 3));

  // Output: 8.000000
}

Constants #

Constants are predefined values that remain fixed during a project. They can be used in calculations without requiring any definition or assignment.

M_PI #

M_PI gives the mathematical constant π, the ratio of a circle’s circumference to its diameter.

Usage:
M_PI

int main() {
  vexcodeInit();

  // Calculate the area of a circle with radius 5
  double area = M_PI * 5 * 5;

  Brain.Screen.print("%f", area);  
  
  // Output: 78.539816
}

M_E #

M_E gives the base of the natural logarithm.

Usage:
M_E

int main() {
  vexcodeInit();

  // Calculate e raised to the power of 2
  double result = pow(M_E, 2);

  Brain.Screen.print("%f", result);  
  
  // Output: 7.389056
}

Trigonometry #

sin #

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

Usage:
sin(x)

Parameter	Description
`x`	A float or integer representing an angle in radians.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();

  // Convert 30 degrees to radians
  double radians = 30 * M_PI / 180.0;

  // Display the sine of 30 degrees
  Brain.Screen.print("%f", sin(radians));

  // Output: 0.500000
}

cos #

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

Usage:
sin(x)

Parameter	Description
`x`	A float or integer representing an angle in radians.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();

  // Convert 60 degrees to radians
  double radians = 60 * M_PI / 180.0;

  // Display the cosine of 60 degrees
  Brain.Screen.print("%f", cos(radians));

  // Output: 0.500000
}

tan #

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

Usage:
tan(x)

Parameter	Description
`x`	A float or integer representing an angle in radians.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();

  // Convert 45 degrees to radians
  double radians = 45 * M_PI / 180.0;

  // Compute tangent of 45 degrees
  Brain.Screen.print("%f", tan(radians));

  // Output: 1.000000
}

atan #

atan calculates the inverse tangent (arc tangent) of a number and returns a float representing the angle in radians.

Usage:
atan(x)

Parameter	Description
`x`	A float or integer representing an angle in radians.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();

  // Calculate the arc tangent of 1 in degrees
  double degrees = atan(1.0) * 180.0 / M_PI;

  Brain.Screen.print("%f", degrees);

  // Output: 45.000000
}

atan2 #

atan2 calculates the principal value of the inverse tangent of y/x and returns a float representing the angle in radians.

Usage:
atan2(y, x)

Parameter	Description
`y`	A float or integer representing the y-coordinate.
`x`	A float or integer representing the x-coordinate.

int main() {
  vexcodeInit();

  // Calculate the inverse tangent of 1/1 in degrees
  double degrees = atan2(1.0, 1.0) * 180.0 / M_PI;

  Brain.Screen.print("%f", degrees);

  // Output: 45.000000
}

asin #

asin calculates the inverse sine (arc sine) of a number and returns a float representing the angle in radians.

Usage:
asin(x)

Parameter	Description
`x`	A float or integer between -1 and 1.

int main() {
  vexcodeInit();

  // Calculate the arc sine of 0.5 in degrees
  double degrees = asin(0.5) * 180.0 / M_PI;

  Brain.Screen.print("%f", degrees);
  
  // Output: 30.000000
}

acos #

acos calculates the inverse cosine (arc cosine) of a number and returns a float representing the angle in radians.

Usage:
acos(x)

Parameter	Description
`x`	A float or integer between -1 and 1.

int main() {
  vexcodeInit();

  // Calculate the arc cosine of 0.5 in degrees
  double degrees = acos(0.5) * 180.0 / M_PI;

  Brain.Screen.print("%f", degrees);  
  
  // Output: 60.000000
}

Rounding & Absolute Value #

ceil #

ceil returns a number rounded up as a float.

Usage:
ceil(x)

Parameter	Description
`x`	A float to be rounded up.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Round up 9.7
  Brain.Screen.print("%f", ceil(9.7));

  // Output: 10.000000
}

floor #

floor returns a number rounded down as a float.

Usage:
floor(x)

Parameter	Description
`x`	A float to be rounded down.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Round down 9.7
  Brain.Screen.print("%f", floor(9.7));

  // Output: 9.000000
}

trunc #

trunc returns a number as a float, with its decimal portion set to zero.

Usage:
trunc(x)

Parameter	Description
`x`	A float to be truncated.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Truncate 9.7
  Brain.Screen.print("%f", trunc(9.7));

  // Output: 9.000000
}

Exponents & Logarithms #

sqrt #

sqrt returns the square root of a number as a float.

Usage:
sqrt(x)

Parameter	Description
`x`	A non-negative float or integer.

int main() {
  // Initializing Robot Configuration. DO NOT REMOVE!
  vexcodeInit();
  // Display the square root of 121
  Brain.Screen.print("%f", sqrt(121));

  // Output: 11.000000
}

exp #

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

Usage:
exp(x)

Parameter	Description
`x`	A float or integer.

int main() {
  vexcodeInit();

  // Calculate e raised to the power of 1
  double result = exp(1);

  Brain.Screen.print("%f", result);
  
  // Output: 2.718282
}

log #

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

Usage:
log(x)

Parameter	Description
`x`	A positive float or integer.

int main() {
  vexcodeInit();

  // Calculate the natural logarithm (base e) of 7.389056
  double result = log(M_E);

  Brain.Screen.print("%f", result);  
  
  // Output: 1.000000
}

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.

int main() {
  vexcodeInit();

  // Calculate the base-10 logarithm of 1000
  double result = log10(1000);

  Brain.Screen.print("%f", result);  
  
  // Output: 3.000000
}

Floating Point Operations #

fmod #

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

Usage:
fmod(x, y)

Parameter	Description
`x`	The dividend.
`y`	The divisor.

int main() {
  vexcodeInit();

  // Calculate remainder of 10 / -3
  // that preserves the sign of 10
  double result = fmod(10.0, -3.0);

  Brain.Screen.print("%f", result);  
  
  // Output: 1.000000
}

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.

int main() {
  vexcodeInit();

  // Return -10 with the sign of 3 (positive)
  double result = copysign(10, -3);

  Brain.Screen.print("%f", result);  
  
  // Output: -10.000000
}