Julia Math Functions

Julia has rich built-in mathematical functions, ideal for scientific computing and data analysis.

Basic Math Functions

Absolute Value and Sign

# Absolute value
println(abs(-5))      # 5
println(abs(-3.14))   # 3.14
println(abs(3 + 4im)) # 5.0 (modulus of complex number)

# Sign function
println(sign(-5))     # -1
println(sign(0))      # 0
println(sign(5))      # 1

# Copy sign
println(copysign(5, -1))   # -5
println(copysign(-5, 1))   # 5

Rounding Functions

x = 3.7
y = -3.7

# Round down (floor)
println(floor(x))     # 3.0
println(floor(y))     # -4.0
println(floor(Int, x)) # 3 (returns integer)

# Round up (ceil)
println(ceil(x))      # 4.0
println(ceil(y))      # -3.0

# Round to nearest (round)
println(round(x))     # 4.0
println(round(y))     # -4.0
println(round(3.5))   # 4.0
println(round(4.5))   # 4.0 (banker's rounding)

# Specify decimal places
println(round(3.14159, digits=2))  # 3.14

# Round toward zero (trunc)
println(trunc(x))     # 3.0
println(trunc(y))     # -3.0

Maximum and Minimum

# Max/min of two numbers
println(max(3, 5))     # 5
println(min(3, 5))     # 3

# Multiple numbers
println(max(1, 5, 3, 9, 2))  # 9
println(min(1, 5, 3, 9, 2))  # 1

# Clamp to range
println(clamp(5, 1, 10))   # 5
println(clamp(-5, 1, 10))  # 1
println(clamp(15, 1, 10))  # 10

Powers and Roots

# Power
println(2^10)         # 1024
println(2.0^0.5)      # 1.414...

# Square root
println(sqrt(16))     # 4.0
println(√16)          # 4.0 (Unicode)

# Cube root
println(cbrt(27))     # 3.0
println(∛27)          # 3.0 (Unicode)

# nth root
println(16^(1/4))     # 2.0

# Square
println(4^2)          # 16

# hypot: compute √(x² + y²), avoids overflow
println(hypot(3, 4))  # 5.0

Exponential and Logarithm

Exponential Functions

# Power of e
println(exp(1))       # 2.718... (e)
println(exp(2))       # 7.389... (e²)

# Power of 2
println(exp2(3))      # 8.0 (2³)

# Power of 10
println(exp10(2))     # 100.0 (10²)

# exp(x) - 1, more accurate for small x
println(expm1(1e-10)) # 1.0e-10 (more accurate than exp(1e-10) - 1)

Logarithm Functions

# Natural logarithm (base e)
println(log(ℯ))       # 1.0
println(log(10))      # 2.302...

# Base 2
println(log2(8))      # 3.0

# Base 10
println(log10(100))   # 2.0

# Arbitrary base
println(log(2, 8))    # 3.0 (log₂8)

# log(1 + x), more accurate for small x
println(log1p(1e-10)) # 1.0e-10

Trigonometric Functions

Basic Trigonometric Functions

# Argument in radians
θ = π / 4  # 45 degrees

println(sin(θ))       # 0.707...
println(cos(θ))       # 0.707...
println(tan(θ))       # 1.0

# Cotangent, secant, cosecant
println(cot(θ))       # 1.0
println(sec(θ))       # 1.414...
println(csc(θ))       # 1.414...

Degree Versions

# Argument in degrees (function name with d)
println(sind(45))     # 0.707...
println(cosd(45))     # 0.707...
println(tand(45))     # 1.0

Inverse Trigonometric Functions

# Returns radians
println(asin(0.5))    # 0.523... (π/6)
println(acos(0.5))    # 1.047... (π/3)
println(atan(1))      # 0.785... (π/4)

# Returns degrees
println(asind(0.5))   # 30.0
println(acosd(0.5))   # 60.0
println(atand(1))     # 45.0

# atan2: arctangent considering quadrant
println(atan(1, 1))   # 0.785... (first quadrant)
println(atan(-1, -1)) # -2.356... (third quadrant)

Hyperbolic Functions

x = 1.0

# Hyperbolic functions
println(sinh(x))      # 1.175...
println(cosh(x))      # 1.543...
println(tanh(x))      # 0.761...

# Inverse hyperbolic functions
println(asinh(1))     # 0.881...
println(acosh(2))     # 1.316...
println(atanh(0.5))   # 0.549...

Special Trigonometric Functions

# sincos: compute sin and cos simultaneously (more efficient)
s, c = sincos(π/4)
println("sin: $s, cos: $c")

# sinpi, cospi: compute sin(πx), cos(πx), more accurate
println(sinpi(0.5))   # 1.0 (sin(π/2))
println(cospi(0.5))   # 0.0 (cos(π/2))

# Angle conversion
println(deg2rad(180)) # 3.14159... (π)
println(rad2deg(π))   # 180.0

Special Functions

Factorial and Combinations

# Factorial
println(factorial(5))     # 120

# Large factorial (use BigInt)
println(factorial(big(50)))

# Binomial coefficient
println(binomial(5, 2))   # 10 (C(5,2))

# Gamma function (generalization of factorial)
println(gamma(6))         # 120.0 (5!)
println(gamma(0.5))       # 1.772... (√π)

# Log gamma
println(lgamma(100))      # Log factorial, avoids overflow

Beta Function

# Beta function
println(beta(2, 3))       # 0.0833...

# Log beta
println(logbeta(2, 3))

Error Function

# Error function
println(erf(1))           # 0.842...
println(erfc(1))          # 1 - erf(1)

# Inverse error function
println(erfinv(0.5))      # 0.476...

Bessel Functions

using SpecialFunctions  # May need installation

# First kind Bessel function
# besselj(ν, x)

# Second kind Bessel function
# bessely(ν, x)

Numerical Precision Functions

# Machine epsilon
println(eps())            # About 2.22e-16
println(eps(Float32))     # Float32 precision

# Next floating point number
println(nextfloat(1.0))   # 1.0000000000000002
println(prevfloat(1.0))   # 0.9999999999999999

# Floating point bit representation
println(significand(3.5)) # Mantissa
println(exponent(3.5))    # Exponent

# Split into integer and fractional parts
int_part, frac_part = modf(3.75)

Common Mathematical Constants

# π (pi)
println(π)           # 3.14159...
println(pi)          # Same

# Natural constant e
println(ℯ)           # 2.71828...

# Infinity
println(Inf)         # Positive infinity
println(-Inf)        # Negative infinity

# Not a Number
println(NaN)         # Not a Number

# Golden ratio (needs calculation)
φ = (1 + √5) / 2
println(φ)           # 1.618...

Complex Number Math Functions

z = 3 + 4im

# Basic functions
println(abs(z))       # 5.0 (modulus)
println(angle(z))     # 0.927... (argument)
println(conj(z))      # 3 - 4im (conjugate)

# Exponential and logarithm
println(exp(z))
println(log(z))

# Trigonometric functions
println(sin(z))
println(cos(z))

# Square root
println(sqrt(-1 + 0im))  # 0.0 + 1.0im

Vectorized Math Operations

x = [0, π/6, π/4, π/3, π/2]

# Vectorize using dot syntax
println(sin.(x))

# Using @. macro
result = @. sin(x)^2 + cos(x)^2
println(result)  # All 1.0

# map function
println(map(sqrt, [1, 4, 9, 16]))

Statistical Functions

using Statistics

data = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# Mean
println(mean(data))       # 5.5

# Median
println(median(data))     # 5.5

# Standard deviation
println(std(data))        # 3.027...

# Variance
println(var(data))        # 9.166...

# Quantiles
println(quantile(data, 0.25))  # 3.25
println(quantile(data, 0.75))  # 7.75

Linear Algebra Functions

using LinearAlgebra

A = [1 2; 3 4]

# Determinant
println(det(A))           # -2.0

# Trace (sum of diagonal elements)
println(tr(A))            # 5

# Inverse matrix
println(inv(A))

# Eigenvalues
println(eigvals(A))

# Norm
println(norm([3, 4]))     # 5.0

# Dot product
println(dot([1, 2], [3, 4]))  # 11

Next Steps

After learning math functions, continue with:

• Strings - String processing
• Functions - Custom functions
• Control Flow - Program logic