# Julia - Basic Mathematical Functions

Let us try to understand basic mathematical functions with the help of example in this chapter.

## Numerical Conversions

In Julia, the user gets three different forms of numerical conversion. All the three differ in their handling of inexact conversions. They are as follows −

T(x) or convert(T, x) − This notation converts x to a value of T. The result depends upon following two cases −

• T is a floating-point type − In this case the result will be the nearest representable value. This value could be positive or negative infinity.

• T is an integer type − The result will raise an InexactError if and only if x is not representable by T.

x%T − This notation will convert an integer x to a value of integer type T corresponding to x modulo 2^n. Here n represents the number of bits in T. In simple words, this notation truncates the binary representation to fit.

Rounding functions − This notation takes a type T as an optional argument for calculation. Eg − Round(Int, a) is shorthand for Int(round(a)).

### Example

The example given below represent the various forms described above −

julia> Int8(110)
110

julia> Int8(128)
ERROR: InexactError: trunc(Int8, 128)
Stacktrace:
 throw_inexacterror(::Symbol, ::Type{Int8}, ::Int64) at .\boot.jl:558
 checked_trunc_sint at .\boot.jl:580 [inlined]
 toInt8 at .\boot.jl:595 [inlined]
 Int8(::Int64) at .\boot.jl:705
 top-level scope at REPL:1

julia> Int8(110.0)
110

julia> Int8(3.14)
ERROR: InexactError: Int8(3.14)
Stacktrace:
 Int8(::Float64) at .\float.jl:689
 top-level scope at REPL:1
julia> Int8(128.0)
ERROR: InexactError: Int8(128.0)
Stacktrace:
 Int8(::Float64) at .\float.jl:689
 top-level scope at REPL:1

julia> 110%Int8
110

julia> 128%Int8
-128

julia> round(Int8, 110.35)
110

julia> round(Int8, 127.52)
ERROR: InexactError: trunc(Int8, 128.0)
Stacktrace:
 trunc at .\float.jl:682 [inlined]
 round(::Type{Int8}, ::Float64) at .\float.jl:367
 top-level scope at REPL:1


## Rounding functions

Following table shows rounding functions that are supported on Julia’s primitive numeric types −

Function Description Return type
round(x) This function will round x to the nearest integer. typeof(x)
round(T, x) This function will round x to the nearest integer. T
floor(x) This function will round x towards -Inf returns the nearest integral value of the same type as x. This value will be less than or equal to x. typeof(x)
floor(T, x) This function will round x towards -Inf and converts the result to type T. It will throw an InexactError if the value is not representable. T
floor(T, x) This function will round x towards -Inf and converts the result to type T. It will throw an InexactError if the value is not representable. T
ceil(x) This function will round x towards +Inf and returns the nearest integral value of the same type as x. This value will be greater than or equal to x. typeof(x)
ceil(T, x) This function will round x towards +Inf and converts the result to type T. It will throw an InexactError if the value is not representable. T
trunc(x) This function will round x towards zero and returns the nearest integral value of the same type as x. The absolute value will be less than or equal to x. typeof(x)
trunc(T, x) This function will round x towards zero and converts the result to type T. It will throw an InexactError if the value is not representable. T

### Example

The example given below represent the rounding functions −

julia> round(3.8)
4.0
julia> round(Int, 3.8)
4
julia> floor(3.8)
3.0
julia> floor(Int, 3.8)
3
julia> ceil(3.8)
4.0
julia> ceil(Int, 3.8)
4
julia> trunc(3.8)
3.0
julia> trunc(Int, 3.8)
3


## Division functions

Following table shows the division functions that are supported on Julia’s primitive numeric types −

Sl.No Function & Description
1

div(x,y), x÷y

It is the quotation from Euclidean division. Also called truncated division. It computes x/y and the quotient will be rounded towards zero.

2

fld(x,y)

It is the floored division. The quotient will be rounded towards -Inf i.e. largest integer less than or equal to x/y. It is shorthand for div(x, y, RoundDown).

3

cld(x,y)

It is ceiling division. The quotient will be rounded towards +Inf i.e. smallest integer less than or equal to x/y. It is shorthand for div(x, y, RoundUp).

4

rem(x,y)

remainder; satisfies x == div(x,y)*y + rem(x,y); sign matches x

5

mod(x,y)

It is modulus after flooring division. This function satisfies the equation x == fld(x,y)*y + mod(x,y). The sign matches y.

6

mod1(x,y)

This is same as mod with offset 1. It returns r∈(0,y] for y>0 or r∈[y,0) for y<0, where mod(r, y) == mod(x, y).

7

mod2pi(x)

It is modulus with respect to 2pi. It satisfies 0 <= mod2pi(x) < 2pi

8

divrem(x,y)

It is the quotient and remainder from Euclidean division. It equivalents to (div(x,y),rem(x,y)).

9

fldmod(x,y)

It is the floored quotation and modulus after division. It is equivalent to (fld(x,y),mod(x,y))

10

gcd(x,y...)

It is the greatest positive common divisor of x, y,...

11

lcm(x,y...)

It represents the least positive common multiple of x, y,...

### Example

The example given below represent the division functions −

julia> div(11, 4)
2

julia> div(7, 4)
1

julia> fld(11, 4)
2

julia> fld(-5,3)
-2

julia> fld(7.5,3.3)
2.0

julia> cld(7.5,3.3)
3.0

julia> mod(5, 0:2)
2

julia> mod(3, 0:2)
0

julia> mod(8.9,2)
0.9000000000000004

julia> rem(8,4)
0

julia> rem(9,4)
1

julia> mod2pi(7*pi/5)
4.39822971502571

julia> divrem(8,3)
(2, 2)

julia> fldmod(12,4)
(3, 0)

julia> fldmod(13,4)
(3, 1)

julia> mod1(5,4)
1

julia> gcd(6,0)
6

julia> gcd(1//3,2//3)
1//3

julia> lcm(1//3,2//3)
2//3


## Sign and Absolute value functions

Following table shows the sign and absolute value functions that are supported on Julia’s primitive numeric types −

Sl.No Function & Function
1

abs(x)

It the absolute value of x. It returns a positive value with the magnitude of x.

2

abs2(x)

It returns the squared absolute value of x.

3

sign(x)

This function indicates the sign of x. It will return -1, 0, or +1.

4

signbit(x)

This function indicates whether the sign bit is on (true) or off (false). In simple words, it will return true if the value of the sign of x is -ve, otherwise it will return false.

5

copysign(x,y)

It returns a value Z which has the magnitude of x and the same sign as y.

6

flipsign(x,y)

It returns a value with the magnitude of x and the sign of x*y. The sign will be flipped if y is negative. Example: abs(x) = flipsign(x,x).

### Example

The example given below represent the sign and absolute value functions −

julia> abs(-7)
7

julia> abs(5+3im)
5.830951894845301

julia> abs2(-7)
49

julia> abs2(5+3im)
34

julia> copysign(5,-10)
-5

julia> copysign(-5,10)
5

julia> sign(5)
1

julia> sign(-5)
-1

julia> signbit(-5)
true

julia> signbit(5)
false

julia> flipsign(5,10)
5

julia> flipsign(5,-10)
-5


## Power, Logs, and Roots

Following table shows the Power, Logs, and Root functions that are supported on Julia’s primitive numeric types −

Sl.No Function & Description
1

sqrt(x), √x

It will return the square root of x. For negative real arguments, it will throw DomainError.

2

cbrt(x), ∛x

It will return the cube root of x. It also accepts the negative values.

3

hypot(x,y)

It will compute the hypotenuse √|𝑥|2+|𝑦|2of right-angled triangle with other sides of length x and y. It is an implementation of an improved algorithm for hypot(a,b) by Carlos and F.Borges.

4

exp(x)

It will compute the natural base exponential of x i.e. 𝑒𝑥

5

expm1(x)

It will accurately compute 𝑒𝑥−1 for x near zero.

6

ldexp(x,n)

It will compute 𝑋 ∗ 2𝑛 efficiently for integer values of n.

7

log(x)

It will compute the natural logarithm of x. For negative real arguments, it will throw DomainError.

8

log(b,x)

It will compute the base b logarithm of x. For negative real arguments, it will throw DomainError.

9

log2(x)

It will compute the base 2 logarithm of x. For negative real arguments, it will throw DomainError.

10

log10(x)

It will compute the base 10 logarithm of x. For negative real arguments, it will throw DomainError.

11

log1p(x)

It will accurately compute the log(1+x) for x near zero. For negative real arguments, it will throw DomainError.

12

exponent(x)

It will calculate the binary exponent of x.

13

significand(x)

It will extract the binary significand (a.k.a. mantissa) of a floating-point number x in binary representation. If x = non-zero finite number, it will return a number of the same type on the interval [1,2), else x will be returned.

### Example

The example given below represent the Power, Logs, and Roots functions −

julia> sqrt(49)
7.0

julia> sqrt(-49)
ERROR: DomainError with -49.0:
sqrt will only return a complex result if called with a complex argument. Try sqrt(Complex(x)).
Stacktrace:
 throw_complex_domainerror(::Symbol, ::Float64) at .\math.jl:33
 sqrt at .\math.jl:573 [inlined]
 sqrt(::Int64) at .\math.jl:599
 top-level scope at REPL:1

julia> cbrt(8)
2.0

julia> cbrt(-8)
-2.0

julia> a = Int64(5)^10;

julia> hypot(a, a)
1.3810679320049757e7

julia> exp(5.0)
148.4131591025766

julia> expm1(10)
22025.465794806718

julia> expm1(1.0)
1.718281828459045

julia> ldexp(4.0, 2)
16.0

julia> log(5,2)
0.43067655807339306

julia> log(4,2)
0.5

julia> log(4)
1.3862943611198906

julia> log2(4)
2.0

julia> log10(4)
0.6020599913279624

julia> log1p(4)
1.6094379124341003

julia> log1p(-2)
ERROR: DomainError with -2.0:
log1p will only return a complex result if called with a complex argument. Try log1p(Complex(x)).
Stacktrace:
 throw_complex_domainerror(::Symbol, ::Float64) at .\math.jl:33
 log1p(::Float64) at .\special\log.jl:356
 log1p(::Int64) at .\special\log.jl:395
 top-level scope at REPL:1
julia> exponent(6.8)
2

julia> significand(15.2)/10.2
0.18627450980392157

julia> significand(15.2)*8
15.2


## Trigonometric and hyperbolic functions

Following is the list of all the standard trigonometric and hyperbolic functions −

sin   cos   tan   cot   sec   csc
sinh  cosh  tanh  coth  sech  csch
asin  acos  atan  acot  asec  acsc
asinh acosh atanh acoth asech acsch
sinc  cosc


Julia also provides two additional functions namely sinpi(x) and cospi(x) for accurately computing sin(pi*x) and cos(pi*x).

If you want to compute the trigonometric functions with degrees, then suffix the functions with d as follows −

sind  cosd  tand  cotd  secd  cscd
asind acosd atand acotd asecd acscd


Some of the example are given below −

julia> cos(56)
0.853220107722584

julia> cosd(56)
0.5591929034707468