Math Functions

Built-in math functions like round, ceil, floor, sqrt, and pow serve various purposes in computer programming. Round() is used to round a floating-point number to the nearest integer, ceil() rounds up to the nearest integer, while floor() rounds down. Sqrt() calculates the square root of a number, and pow() raises a number to a specified power. These functions are essential for tasks such as data manipulation, numerical analysis, and algorithm development, enabling programmers to perform complex mathematical operations accurately and efficiently within their code, enhancing both readability and computational performance.

Select Languages

Examples

C

#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <time.h>

float power = pow(3.0, 6.0);
printf("%f \n", power);

float root = sqrt(16.0);
printf("%f \n", root);

float floorVal = floor(3.14);
printf("%f \n", power);

float ceilVal = ceil(4.3);
printf("%f \n",  power);

float roundVal = round(3.4);
printf("%f \n", roundVal);

// random number from 0 to 100
srand(time(NULL));
int ranNum = rand() % 101;
printf("%d \n", ranNum);

C#

double power = Math.pow(3.0, 6.0);
Console.WriteLine(power);

double root = Math.Sqrt(16.0);
Console.WriteLine(root);

double floorVal = Math.Floor(3.14);
Console.WriteLine(floorVal);

double ceilVal = Math.Ceiling(4.3);
Console.WriteLine(ceilVal);

double roundVal = Math.Round(3.4);
Console.WriteLine(roundVal);

// random number from 0 to 100
Random rand = new Random();
int ranNum = rand.Next(0, 101);
Console.WriteLine(ranNum);

C++

float power = pow(3.0, 6.0);
cout << power << endl;

float root = sqrt(16.0);
cout << root << endl;

float floorVal = floor(3.14);
cout << floorVal << endl;

float ceilVal = ceil(4.3);
cout << ceilVal << endl;

float roundVal = round(3.4);
cout << roundVal << endl;

// random number from 0 to 100
random_device rd;
mt19937 gen(rd());
uniform_int_distribution<> dis(0, 100);
int ranNum = dis(gen);
cout << ranNum << endl;

Go

package main
import ( 
  "fmt"
  "math"
  "math/rand"
  "time"
)

var power = math.pow(3, 6);
fmt.Println(power);

var root = math.Sqrt(16.0);
fmt.Println(root);

var floorVal = math.Floor(3.14);
fmt.Println(floorVal);

var ceilVal = math.Ceil(4.3);
fmt.Println(ceilVal);

var roundVal = math.Round(3.4);
fmt.Println(roundVal);

// random number from 0 to 100
rand.Seed(time.Now().UnixNano());
ranNum := rand.Intn(101);
fmt.Println(ranNum);

Java

import java.lang.Math;

double power = Math.pow(3.0, 6.0);
System.out.println(power);

double root = Math.sqrt(16.0);
System.out.println(root);

double floorVal = Math.floor(3.14);
System.out.println(floorVal);

double ceilVal = Math.ceil(4.3);
System.out.println(ceilVal);

double roundVal = Math.round(3.4);
System.out.println(roundVal);

// random number from 0 to 100
int ranNum = (int)(Math.random() * 101);
System.out.println(ranNum);

JavaScript

const power = Math.pow(3.0, 6.0);
console.log(power);

const root = Math.sqrt(16.0);
console.log(root);

const floorVal = Math.floor(3.14);
console.log(floorVal);

const ceilVal = Math.ceil(4.3);
console.log(ceilVal);

const roundVal = Math.round(3.4);
console.log(roundVal);

// random number from 0 to 100
const ranNum =
  Math.floor(Math.random() * 100) + 1
console.log(ranNum);

Kotlin

import kotlin.math.*;
import kotlin.random.Random;

val power = Math.pow(3.0, 6.0);
println(power );

val root = Math.sqrt(16.0);
println(root );

val floorVal = Math.floor(3.14);
println(floorVal );

val ceilVal = Math.ceil(4.3);
println(ceilVal );

val roundVal = Math.round(3.4);
println(roundVal );

// random number from 0 to 100
val random = Random
val ranNum = random.nextInt(0, 101)
println(ranNum)

MatLab

power = 3 .^ 6;
disp(power);

root = sqrt(16);
disp(root);

floorVal = floor(3.14);
disp(floorVal);

ceilVal = ceil(4.3);
disp(ceilVal);

roundVal = round(3.4);
disp(roundVal);

% random number from 0 to 100
ranNum = randi([0, 100]);
disp(ranNum);

PHP

$power = pow(3, 6);
echo $power. "\n";

$root = sqrt(16);
echo $root. "\n";

$floorVal = floor(3.14);
echo $floorVal. "\n";

$ceilVal = ceil(4.3);
echo $ceilVal. "\n";

$roundVal = round(3.4);
echo $roundVal. "\n";

// random number from 0 to 100
$random_number = mt_rand(0, 100);
echo $random_number. "\n";

Python

import math
from random import randint

power = math.pow(3, 6);
print(power);

root = math.sqrt(16);
print(root);

floorVal = math.floor(3.14);
print(floorVal);

ceilVal = math.ceil(4.3);
print(ceilVal);

roundVal = round(3.4);
print(roundVal);

# random number from 0 to 100
ranNum = randint(0, 100)
print(ranNum)

R

power <- 3 ^ (6)
print(power)

root <- sqrt(16)
print(root)

floorVal <- floor(3.14)
print(floorVal)

ceilVal <- ceiling(4.3)
print(ceilVal)

roundVal <- round(3.4)
print(roundVal)

# random number from 0 to 100
ranNum <- sample(0:100, 1)
print(ranNum)

Ruby

power = 3.pow(6)
puts power

root = Math.sqrt(16)
puts root

floorVal = 3.14.floor()
puts floorVal

ceilVal = 4.3.ceil()
puts ceilVal

roundVal = 3.4.round()
puts roundVal

# random number from 0 to 100
ranNum = rand(0..100)
puts ranNum

Rust

let power = f64::powf(3.0, 6.0);
println!("{}", power);

let root = 16.0_f64.sqrt();
println!("{}", root);

let floor_val = 3.14_f64.floor();
println!("{}", floor_val);

let ceil_val = 4.3_f64.ceil();
println!("{}", ceil_val);

let round_val = 3.4_f64.round();
println!("{}", round_val);

Scala

val power = pow(3, 6);
println(power);

val root = sqrt(16);
println(root);

val floorVal = floor(3.14);
println(floorVal);

val ceilVal = ceil(4.3);
println(ceilVal);

val roundVal = round(3.4);
println(roundVal);

// random number from 0 to 100
val ranNum = Random.between(0, 101)
println(ranNum);

Swift

import Foundation

let power = pow(3, 6);
print(power);

let root = sqrt(16);
print(root);

let floorVal = floor(3.14);
print(floorVal);

let ceilVal = ceil(4.3);
print(ceilVal);

let roundVal = round(3.4);
print(roundVal);

// random number from 0 to 100
let ranNum = Int.random(in: 0..< 101)
print(ranNum);

TypeScript

const power: number = Math.pow(3, 6);
console.log(power);

const root: number = Math.sqrt(16);
console.log(root);

const floorVal: number = Math.floor(3.14);
console.log(floorVal);

const ceilVal: number = Math.ceil(4.3);
console.log(ceilVal);

const roundVal: number = Math.round(3.4);
console.log(roundVal);

// random number from 0 to 100
const ranNum: number =
  Math.floor(Math.random() * 100) + 1;
console.log(ranNum);

Copyright 2025. All Rights Reserved. IronCodeMan.