From Code to Community: Sponsoring The Perl and Raku Conference 2025 Learn more

 / 
Sidef-24.11
River stage one • 1 direct dependent • 1 total dependent
/ Sidef::Math::Math

NAME

Sidef::Math::Math

DESCRIPTION

The Math class implements several useful mathematical functions.

SYNOPSIS


            

              
              
say Math.lcm(3,4,5)
say Math.avg(1,2,3,4)

INHERITS

Inherits methods from:


            

              
              
* Sidef::Object::Object

METHODS

avg


            

              
              
Math.avg(list...)

Returns the arithmetic mean of a list of numbers.


            

              
              
say Math.avg(42, 50, 99, 147)       #=> 84.5

Aliases: arithmetic_mean

batch_gcd


            

              
              
Math.batch_gcd(list...)

Efficiently computes the batch-gcd of a list of integers.


            

              
              
say Math.batch_gcd(1909,2923,291,205,989,62,451,1943,1079,2419)

Output:


            

              
              
[1909, 1, 1, 41, 23, 1, 41, 1, 83, 41]

batch_invmod


            

              
              
Math.batch_invmod(array, n)

Efficiently computes the modular multiplicative inverses of a list of integers, modulo n.


            

              
              
say Math.batch_invmod([33, 42, 99, 103], 2017)      #=> [489, 1969, 163, 235]

binary_exp


            

              
              
Math.binary_exp(c, x, n, {|a,b| ... })

Generic implementation of the binary exponentiation algorithm, using the binary expansion of n.


            

              
              
say Math.binary_exp(1, 3, 43, {|a,b| a * b })  #=> 3^43
say Math.binary_exp(0, 3, 43, {|a,b| a + b })  #=> 3*43

binsplit


            

              
              
Math.binsplit(block, list...)

Binary splitting algorithm.


            

              
              
var arr = [1,2,3,4,5,6,7]
# Sum of a list using binary splitting
say Math.binsplit({|a,b| a + b }, arr...)
# Product of a list using binary splitting
say Math.binsplit({|a,b| a * b }, arr...)

chinese


            

              
              
Math.chinese(pairs...)

Returns the solution for x in x ≡ a_k (mod m_k), using the Chinese Remainder Theorem (CRT), given a list of pairs [a_k,m_k]:


            

              
              
say Math.chinese([14,643], [254,419], [87,733])     #=> 87041638

for


            

              
              
Math.for(initial, conditionBlock, nextTermBlock)

Returns an Enumerator object, generating a sequence of numbers based on the conditionBlock and nextTermBlock blocks.


            

              
              
Math.for(1, { _ <= 10 }, { .inc }).each { .say }     # count from 1 to 10

The value of conditionBlock can be nil, which creates an infinite Enumerator object:


            

              
              
say Math.for(2, nil, { .next_prime }).first(25)      # array of first 25 primes

gcd


            

              
              
Math.gcd(list...)

Returns the greatest common divisor (GCD) of a list of integers.

gcd_factors


            

              
              
Math.gcd_factors(n, [a, b, ...])

Given a positive integer and an array of integers, it tries to find non-trivial factors of n, checking each gcd(n, array[0]), gcd(n, array[1]), etc.


            

              
              
var n = 43*43*97*503
var a = [19*43*97, 1, 13*41*43*101]
say Math.gcd_factors(n, a)          #=> [43, 43, 97, 503]

The product of the factors gives back n. However, some factors may be composite.

geometric_mean


            

              
              
Math.geometric_mean(list...)

Returns the geometric mean of a list of numbers.


            

              
              
say Math.geometric_mean(42, 50, 99, 147)        #=> 74.352051512093712...

harmonic_mean


            

              
              
Math.harmonic_mean(list...)

Returns the harmonic mean of a list of numbers.


            

              
              
say Math.harmonic_mean(42, 50, 99, 147)         #=> 65.883471411109602...

lcm


            

              
              
Math.lcm(list...)

Returns the least common multiple (LCM) of a list of integers.

linear_rec


            

              
              
Math.linear_rec(ker, init, n)
Math.linear_rec(ker, init, from, to)

Returns the n-th term or the terms with indices in the range from .. to (as an Array object), by iterating the linear recurrence with kernel ker starting with initial values init.


            

              
              
say Math.linear_rec([1, 1], [0, 1], 0, 5)                    #=> [0, 1, 1, 2, 3, 5]
say Math.linear_rec([3, -3, 1], [0, 1, 3], 0, 5)             #=> [0, 1, 3, 6, 10, 15]
say Math.linear_rec([4, -6, 4, -1], [0, 1, 5, 14], 100000)   #=> 333338333350000

Aliases: linear_recurrence

linear_recmod


            

              
              
Math.linear_recmod(ker, init, n, m)

Returns the n-th term modulo m, defined by the linear recurrence with kernel ker starting with initial values init.


            

              
              
say Math.linear_recmod([1, 1], [0, 1], 43, 43)     #=> 42 (== fibmod(43,43))

Aliases: linear_recurrence_mod

linear_recurrence_matrix


            

              
              
Math.linear_recurrence_matrix(ker)

Returns a Matrix object that represents the given linear recurrence kernel.

map


            

              
              
Math.map(value, in_min, in_max, out_min, out_max)

Return a given value mapped from a given range to another given range.


            

              
              
# Map 25 from 1..100, to 1..10
say Math.map(25, 1, 100, 1, 10)     #=> 3.181818181...

max


            

              
              
Math.max(list...)

Returns the largest numerical value from a list of numbers.

min


            

              
              
Math.min(list...)

Returns the smallest numerical value from a list of numbers.

num2percent


            

              
              
Math.num2percent(num, min, max)

Returns a given value as a percentage, given min and max of the value range.


            

              
              
# Map the value 25 as a percentage, from a range 1..400
say Math.num2percent(25, 1, 400)        #=> 6.01503759398...

prod


            

              
              
Math.prod(list...)

Returns the product of a list of numbers.

Aliases: product

product_tree


            

              
              
Math.product_tree(list...)

Return the product-tree of a list of integers.


            

              
              
say Math.product_tree(10,20,30,40,50,60)

range_map


            

              
              
Math.range_map(amount, from, to)

Returns a RangeNumber object with the amount value mapped between the values from and to.


            

              
              
say Math.range_map(10, 2, 5)    #=> RangeNum(2, 5, 3/10)

range_sum


            

              
              
Math.range_sum(from, to, step)

Returns the sum of a given range and an optional given step.


            

              
              
say Math.range_sum(1, 10)      #=> 55
say Math.range_sum(1, 10, 2)   #=> 30.25

remainders


            

              
              
Math.remainders(n, array)

Efficiently returns the remainders of n when divided by each integer from the given array.


            

              
              
say Math.remainders(8675309, [11,13,17,19,23])      #=> [5, 6, 5, 4, 8]

seq


            

              
              
Math.seq(x, y, z, ..., {|a,n| ... })

Returns an Enumerator object which generates an infinite sequence specified by the initial terms and the given block.

Example:


            

              
              
say Math.seq(2, { .last.next_prime }).first(30)     # prime numbers
say Math.seq(1, 1, { .last(2).sum }).first(30)      # Fibonacci numbers

smooth_numbers


            

              
              
Math.smooth_numbers(primes...)

It returns an Enumerator object, which generates smooth numbers using the given list of primes.

Example:


            

              
              
var a = Math.smooth_numbers(2,3,5,7)    # 7-smooth numbers
var b = Math.smooth_numbers(2,5,7)      # 7-smooth numbers not divisible by 3
say a.first(30)
say b.first(30)
# Iteration is also supported
a.each {|k|
    if (k > 1e5) {
        say k           #=> 100352
        break
    }
}

solve_rec_seq


            

              
              
Math.solve_rec_seq(array)

Attempts to find a minimal linear recurrence that generates the given array of numbers:


            

              
              
say Math.solve_rec_seq(30.of { .fibonacci })      #=> [1, 1]
say Math.solve_rec_seq(30.of { .square })         #=> [3, -3, 1]
say Math.solve_rec_seq(30.of { .faulhaber(2) })   #=> [4, -6, 4, -1]

Aliases: find_linear_recurrence

solve_seq


            

              
              
Math.solve_seq(array, offset=0)

Returns a Polynomial object that generates the terms of the given sequence.

Example:


            

              
              
say Math.solve_seq(20.of { .square })         #=> x^2
say Math.solve_seq(20.of { .faulhaber(2) })   #=> 1/3*x^3 + 1/2*x^2 + 1/6*x

Example with offset:


            

              
              
say Math.solve_seq(20.of { (_+10)**3 })       #=> x^3 + 30*x^2 + 300*x + 1000
say Math.solve_seq(20.of { (_+10)**3 }, 10)   #=> x^3

sum


            

              
              
Math.sum(list...)

Returns the sum of a list of numbers.