/ 
Sidef-24.01
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.