Standard mathematical functions in Kotlin

Kotlin provides a standard set of functions for mathematical operations. These are in a separate package called 'kotlin.math' outsourced and are only imported into the code of an application when necessary. Importing functions that are not available by default in a language is common in many programming languages ​​to reduce the size of the generated program and possible naming conflicts.

To get mathematical functions from the kotlin.mathlibrary, an import statement is inserted at the beginning of the Kotlin source code. There is the option of either all elements of the kotlin.mathlibrary using the so-called wildcard import statement import kotlin.math.* to import or explicitly use individual functions import kotlin.math.NameOfFunction to load into the program.

import kotlin.math.*    // Mit der Wildcard-Import-Anweisung wird die gesamte kotlin.math-Bibliothek importiert 
import kotlin.math.abs  // Import der Funktion abs() aus der Bibliothek
import kotlin.math.pow  // Import der Funktion pow() aus der Bibliothek

Although in some cases it may be convenient to import the entire library, especially if many functions from the package are used, it is generally recommended to only the functions you need to import to take advantage of the previously mentioned benefits. In the following explanations of common Kotlin standard mathematical functions, we will only use this approach.

abs ()

Process abs () calculates the absolute value of a number. The function can be used for different numeric data types like Int, Long, Float and Double should be used. 

To the abs ()To use the function, this must be checked in advance kotlin.mathlibrary using the statement import kotlin.math.abs Imported.

Here are some examples like that abs ()-Function can be used for different data types:

import kotlin.math.abs  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val intValue = -5
    val absoluteIntValue = abs(intValue) 
    println(absoluteIntValue)  // Ergebnis: 5
    
    val floatValue = -3.14f
    val absoluteFloatValue = abs(floatValue) 
    println(absoluteFloatValue)  // Ergebnis: 3.14

    val doubleValue = -6.28
    val absoluteDoubleValue = abs(doubleValue) 
    println(absoluteDoubleValue)  // Ergebnis: 6.28
}

Application example: The abs ()function is often used in mathematical calculations and algorithms that require the magnitude of a number (regardless of sign).

pow ()

In Kotlin, the power function is not directly available, but it can be accessed from the just like previous function kotlin.mathLibrary with the instruction kotlin.math.pow Imported.

import kotlin.math.pow  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val base = 2.0
    val exponent = 3.0
    val result = base.pow(exponent) 
    println(result) // Ergebnis: 8.0
}

Application example: Calculating compound interest in a financial application.

Round(), ceil() and floor() functions for rounding numbers

round (), ceil() and floor() are mathematical functions in Kotlin that are used to round numbers. Each function has its own specific use and differs in the way it rounds a number. Here are the differences between the three features:

The round ()function rounds a decimal number to the nearest integer. If the decimal value is greater than or equal to 0,5, the number is rounded up to the next higher integer. If the decimal value is less than 0,5, the number is rounded down to the next lower integer.

import kotlin.math.round  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val number1 = 3.4
    val rounded1 = round(number1) 
    println(rounded1)  // Ergebnis: 3.0

    val number2 = 3.6
    val rounded2 = round(number2) 
    println(rounded2) // Ergebnis: 4.0
}

The ceil()-Function (short for “ceiling”) always rounds a decimal number to the next higher integer, regardless of its decimal value.

import kotlin.math.ceil  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val number1 = 3.1
    val ceil1 = ceil(number1) 
    println(ceil1)  // Ergebnis:  4.0

    val number2 = 3.9
    val ceil2 = ceil(number2) 
    println(ceil2)  // Ergebnis: 4.0
}

The floor()function always rounds a decimal number to the next lower integer, regardless of its decimal value.

import kotlin.math.floor  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val number1 = 3.1
    val floor1 = floor(number1) 
    println(number1)  // Ergebnis: 3.0

    val number2 = 3.9
    val floor2 = floor(number2) 
    println(floor2)  // Ergebnis: 3.0
}

In summary: round () rounds a number to the nearest integer based on its decimal value. ceil() always rounds up to the next higher integer, while floor() always rounds down to the next lower integer.

Application example: Pricing calculation in an e-commerce application that requires prices to be rounded up or down.

max() and min()

max () and min () are mathematical functions in Kotlin that are used to find the larger or smaller value between two numbers. Both functions are available in Kotlin's standard library and can be used for various numeric data types such as Int, Long, Float and Double should be used.

The max ()function returns the larger value between two numbers. If both numbers are the same, it returns one of the two values.

import kotlin.math.max  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val number1 = 5
    val number2 = 10
    val maxValue = max(number1, number2) 
    println(maxValue)  // Ergebnis: 10
}

Application example: Determining the larger value from a list of numbers or finding the highest value in a data series.

The min ()function returns the smaller value between two numbers. If both numbers are the same, it returns one of the two values.

import kotlin.math.min  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val number1 = 5
    val number2 = 10
    val minValue = min(number1, number2) 
    println(minValue)  // Ergebnis: 5
}

Application example: Determining the smaller value from a list of numbers or finding the lowest value in a data series.

max () and min () are useful functions that can be used in many different use cases, such as finding extreme values, performing calculations, or making decisions based on numerical values.

sqrt ()

The sqrt ()-Function (short for “square root”) is a mathematical function in Kotlin that calculates the square root of a given number. The function is available in the Kotlin standard library and works on the numeric data type Double. Here is an example like that sqrt ()-Function can be used:

import kotlin.math.sqrt  // Import der Funktion aus der kotlin.math-Bibliothek

fun main() {
    val number = 16.0
    val squareRoot = sqrt(number) 
    println(squareRoot)  // Ergebnis: 4.0
}

In this example the calculates sqrt ()-Function the square root of 16, and the result is 4.

The square root function is useful in various use cases, such as: B. when calculating distances between points in two-dimensional or three-dimensional space (using the Pythagorean theorem), when estimating statistical values ​​such as the standard deviation, or when solving mathematical or physics problems that require the calculation of roots.

Trigonometric functions: sin(), cos(), tan()

Trigonometric functions are fundamental mathematical functions that play an important role in geometry and many scientific and engineering applications. In Kotlin the trigonometric functions are without(), cos () and so() available in the standard library. They are used to calculate the sine, cosine and tangent values ​​of a given angle. To use the trigonometric functions in Kotlin, the angle to be calculated must be converted to radians. The function can do this Math.toRadians() can be used as shown in the examples below.

import kotlin.math.sin
import kotlin.math.cos
import kotlin.math.tan // Import der Funktionen aus der kotlin.math-Bibliothek

fun main() {
    val angle = 45.0
    val angleInRadians = Math.toRadians(angle) // Umwandlung in Radiant
    val sine = sin(angleInRadians)
    println(sine)   // Ergebnis: 0.7071067811865475
    val cosine = cos(angleInRadians)
    println(cosine)  // Ergebnis: 0.7071067811865476
    val tangent = tan(angleInRadians)
    println(tangent)  // Ergebnis: 0.9999999999999999
}

Application example: Calculating angles and distances for computer graphics and animation, especially when transforming coordinates and rotating objects.

The standard math functions provided in Kotlin allow you to efficiently handle a variety of mathematical operations and calculations.