2019-06-22 21:20:28 +03:00
|
|
|
// Copyright (c) 2019 Alexander Medvednikov. All rights reserved.
|
|
|
|
// Use of this source code is governed by an MIT license
|
|
|
|
// that can be found in the LICENSE file.
|
|
|
|
|
|
|
|
module math
|
|
|
|
|
2019-10-15 04:46:40 +03:00
|
|
|
#include <math.h>
|
|
|
|
|
2019-11-07 22:04:18 +03:00
|
|
|
fn C.acos(x f64) f64
|
|
|
|
fn C.asin(x f64) f64
|
|
|
|
fn C.atan(x f64) f64
|
|
|
|
fn C.atan2(y f64, x f64) f64
|
|
|
|
fn C.cbrt(x f64) f64
|
|
|
|
fn C.ceil(x f64) f64
|
|
|
|
fn C.cos(x f64) f64
|
|
|
|
fn C.cosh(x f64) f64
|
|
|
|
fn C.erf(x f64) f64
|
|
|
|
fn C.erfc(x f64) f64
|
|
|
|
fn C.exp(x f64) f64
|
|
|
|
fn C.exp2(x f64) f64
|
2019-12-15 19:37:17 +03:00
|
|
|
fn C.fabs(x f64) f64
|
2019-11-07 22:04:18 +03:00
|
|
|
fn C.floor(x f64) f64
|
|
|
|
fn C.fmod(x f64, y f64) f64
|
|
|
|
fn C.hypot(x f64, y f64) f64
|
|
|
|
fn C.log(x f64) f64
|
|
|
|
fn C.log2(x f64) f64
|
|
|
|
fn C.log10(x f64) f64
|
|
|
|
fn C.lgamma(x f64) f64
|
|
|
|
fn C.pow(x f64, y f64) f64
|
|
|
|
fn C.round(x f64) f64
|
|
|
|
fn C.sin(x f64) f64
|
2019-11-24 06:27:02 +03:00
|
|
|
fn C.sinh(x f64) f64
|
2019-11-07 22:04:18 +03:00
|
|
|
fn C.sqrt(x f64) f64
|
|
|
|
fn C.tgamma(x f64) f64
|
|
|
|
fn C.tan(x f64) f64
|
|
|
|
fn C.tanh(x f64) f64
|
|
|
|
fn C.trunc(x f64) f64
|
|
|
|
|
|
|
|
|
2019-07-12 08:01:12 +03:00
|
|
|
// NOTE
|
|
|
|
// When adding a new function, please make sure it's in the right place.
|
2019-07-17 01:03:51 +03:00
|
|
|
// All functions are sorted alphabetically.
|
2019-07-12 08:01:12 +03:00
|
|
|
|
2019-06-30 16:33:37 +03:00
|
|
|
// Returns the absolute value.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn abs(a f64) f64 {
|
2019-12-15 19:37:17 +03:00
|
|
|
return C.fabs(a)
|
2019-06-22 21:20:28 +03:00
|
|
|
}
|
|
|
|
|
2019-09-14 23:54:14 +03:00
|
|
|
// acos calculates inverse cosine (arccosine).
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn acos(a f64) f64 {
|
2019-06-24 17:05:30 +03:00
|
|
|
return C.acos(a)
|
|
|
|
}
|
|
|
|
|
2019-09-14 23:54:14 +03:00
|
|
|
// asin calculates inverse sine (arcsine).
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn asin(a f64) f64 {
|
2019-06-24 17:05:30 +03:00
|
|
|
return C.asin(a)
|
|
|
|
}
|
|
|
|
|
2019-09-14 23:54:14 +03:00
|
|
|
// atan calculates inverse tangent (arctangent).
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn atan(a f64) f64 {
|
2019-06-24 17:05:30 +03:00
|
|
|
return C.atan(a)
|
|
|
|
}
|
|
|
|
|
2019-09-14 23:54:14 +03:00
|
|
|
// atan2 calculates inverse tangent with two arguments, returns the angle between the X axis and the point.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn atan2(a, b f64) f64 {
|
2019-06-24 17:05:30 +03:00
|
|
|
return C.atan2(a, b)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// cbrt calculates cubic root.
|
2019-06-30 16:33:37 +03:00
|
|
|
pub fn cbrt(a f64) f64 {
|
2019-07-02 13:50:33 +03:00
|
|
|
return C.cbrt(a)
|
2019-06-30 16:33:37 +03:00
|
|
|
}
|
|
|
|
|
2019-11-07 19:54:51 +03:00
|
|
|
// ceil returns the nearest f64 greater or equal to the provided value.
|
|
|
|
pub fn ceil(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.ceil(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// cos calculates cosine.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn cos(a f64) f64 {
|
2019-06-22 21:20:28 +03:00
|
|
|
return C.cos(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// cosh calculates hyperbolic cosine.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn cosh(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.cosh(a)
|
|
|
|
}
|
|
|
|
|
2019-07-12 08:46:40 +03:00
|
|
|
// degrees convert from degrees to radians.
|
|
|
|
pub fn degrees(radians f64) f64 {
|
2019-10-12 22:31:05 +03:00
|
|
|
return radians * (180.0 / pi)
|
2019-07-12 08:46:40 +03:00
|
|
|
}
|
|
|
|
|
2019-09-14 23:54:14 +03:00
|
|
|
// exp calculates exponent of the number (math.pow(math.E, a)).
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn exp(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.exp(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// digits returns an array of the digits of n in the given base.
|
2019-08-06 19:13:04 +03:00
|
|
|
pub fn digits(_n, base int) []int {
|
2019-11-11 05:21:47 +03:00
|
|
|
if base < 2 {
|
|
|
|
panic('digits: Cannot find digits of n with base $base')
|
|
|
|
}
|
2019-09-16 21:26:05 +03:00
|
|
|
mut n := _n
|
2019-07-02 13:50:33 +03:00
|
|
|
mut sign := 1
|
|
|
|
if n < 0 {
|
|
|
|
sign = -1
|
|
|
|
n = -n
|
|
|
|
}
|
|
|
|
mut res := []int
|
|
|
|
for n != 0 {
|
|
|
|
res << (n % base) * sign
|
|
|
|
n /= base
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
2019-09-14 23:54:14 +03:00
|
|
|
// erf computes the error function value
|
2019-07-12 08:46:40 +03:00
|
|
|
pub fn erf(a f64) f64 {
|
|
|
|
return C.erf(a)
|
|
|
|
}
|
|
|
|
|
2019-09-14 23:54:14 +03:00
|
|
|
// erfc computes the complementary error function value
|
2019-07-12 08:46:40 +03:00
|
|
|
pub fn erfc(a f64) f64 {
|
|
|
|
return C.erfc(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// exp2 returns the base-2 exponential function of a (math.pow(2, a)).
|
2019-06-30 16:33:37 +03:00
|
|
|
pub fn exp2(a f64) f64 {
|
2019-07-02 13:50:33 +03:00
|
|
|
return C.exp2(a)
|
2019-06-30 16:33:37 +03:00
|
|
|
}
|
|
|
|
|
2019-07-12 08:46:40 +03:00
|
|
|
// factorial calculates the factorial of the provided value.
|
2019-12-03 11:34:26 +03:00
|
|
|
pub fn factorial(n f64) f64 {
|
|
|
|
// For a large postive argument (n >= factorials.len) return max_f64
|
|
|
|
|
|
|
|
if n >= factorials.len {
|
|
|
|
return max_f64
|
|
|
|
}
|
|
|
|
|
2019-12-07 17:13:25 +03:00
|
|
|
// Otherwise return n!.
|
2019-12-03 11:34:26 +03:00
|
|
|
if n == f64(i64(n)) && n >= 0.0 {
|
2019-12-07 17:13:25 +03:00
|
|
|
return factorials[i64(n)]
|
2019-12-03 11:34:26 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
return gamma(n + 1.0)
|
|
|
|
}
|
2019-07-12 08:46:40 +03:00
|
|
|
|
2019-11-07 19:54:51 +03:00
|
|
|
// floor returns the nearest f64 lower or equal of the provided value.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn floor(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.floor(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// fmod returns the floating-point remainder of number / denom (rounded towards zero):
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn fmod(a, b f64) f64 {
|
2019-06-24 14:08:38 +03:00
|
|
|
return C.fmod(a, b)
|
2019-06-24 11:50:45 +03:00
|
|
|
}
|
|
|
|
|
2019-07-12 08:46:40 +03:00
|
|
|
// gamma computes the gamma function value
|
|
|
|
pub fn gamma(a f64) f64 {
|
|
|
|
return C.tgamma(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// gcd calculates greatest common (positive) divisor (or zero if a and b are both zero).
|
2019-08-07 09:19:27 +03:00
|
|
|
pub fn gcd(a_, b_ i64) i64 {
|
2019-09-16 21:26:05 +03:00
|
|
|
mut a := a_
|
|
|
|
mut b := b_
|
2019-06-29 18:24:55 +03:00
|
|
|
if a < 0 {
|
|
|
|
a = -a
|
|
|
|
}
|
|
|
|
if b < 0 {
|
|
|
|
b = -b
|
|
|
|
}
|
|
|
|
for b != 0 {
|
|
|
|
a %= b
|
|
|
|
if a == 0 {
|
|
|
|
return b
|
|
|
|
}
|
|
|
|
b %= a
|
|
|
|
}
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
|
2019-07-23 19:28:30 +03:00
|
|
|
// Returns hypotenuse of a right triangle.
|
|
|
|
pub fn hypot(a, b f64) f64 {
|
|
|
|
return C.hypot(a, b)
|
|
|
|
}
|
|
|
|
|
2019-06-29 18:24:55 +03:00
|
|
|
// lcm calculates least common (non-negative) multiple.
|
2019-07-03 19:51:03 +03:00
|
|
|
pub fn lcm(a, b i64) i64 {
|
2019-06-29 18:24:55 +03:00
|
|
|
if a == 0 {
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
res := a * (b / gcd(b, a))
|
|
|
|
if res < 0 {
|
|
|
|
return -res
|
|
|
|
}
|
|
|
|
return res
|
|
|
|
}
|
|
|
|
|
2019-07-12 21:45:56 +03:00
|
|
|
// log calculates natural (base-e) logarithm of the provided value.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn log(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.log(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// log2 calculates base-2 logarithm of the provided value.
|
2019-06-30 16:33:37 +03:00
|
|
|
pub fn log2(a f64) f64 {
|
2019-07-11 09:26:31 +03:00
|
|
|
return C.log2(a)
|
2019-06-30 16:33:37 +03:00
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// log10 calculates the common (base-10) logarithm of the provided value.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn log10(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.log10(a)
|
|
|
|
}
|
|
|
|
|
2019-07-12 08:46:40 +03:00
|
|
|
// log_gamma computes the log-gamma function value
|
|
|
|
pub fn log_gamma(a f64) f64 {
|
|
|
|
return C.lgamma(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// log_n calculates base-N logarithm of the provided value.
|
2019-06-30 16:33:37 +03:00
|
|
|
pub fn log_n(a, b f64) f64 {
|
|
|
|
return C.log(a) / C.log(b)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// max returns the maximum value of the two provided.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn max(a, b f64) f64 {
|
2019-06-22 21:20:28 +03:00
|
|
|
if a > b {
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
return b
|
|
|
|
}
|
|
|
|
|
2019-07-12 21:45:56 +03:00
|
|
|
// min returns the minimum value of the two provided.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn min(a, b f64) f64 {
|
2019-06-22 21:20:28 +03:00
|
|
|
if a < b {
|
|
|
|
return a
|
|
|
|
}
|
|
|
|
return b
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// pow returns base raised to the provided power.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn pow(a, b f64) f64 {
|
2019-06-22 21:20:28 +03:00
|
|
|
return C.pow(a, b)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// radians convert from radians to degrees.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn radians(degrees f64) f64 {
|
2019-10-12 22:31:05 +03:00
|
|
|
return degrees * (pi / 180.0)
|
2019-06-22 21:20:28 +03:00
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// round returns the integer nearest to the provided value.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn round(f f64) f64 {
|
2019-06-22 21:20:28 +03:00
|
|
|
return C.round(f)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// sin calculates sine.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn sin(a f64) f64 {
|
2019-06-22 21:20:28 +03:00
|
|
|
return C.sin(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// sinh calculates hyperbolic sine.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn sinh(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.sinh(a)
|
|
|
|
}
|
|
|
|
|
2019-07-12 21:45:56 +03:00
|
|
|
// sqrt calculates square-root of the provided value.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn sqrt(a f64) f64 {
|
2019-06-22 21:20:28 +03:00
|
|
|
return C.sqrt(a)
|
|
|
|
}
|
2019-07-02 13:50:33 +03:00
|
|
|
// tan calculates tangent.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn tan(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.tan(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// tanh calculates hyperbolic tangent.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn tanh(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.tanh(a)
|
|
|
|
}
|
|
|
|
|
2019-07-02 13:50:33 +03:00
|
|
|
// trunc rounds a toward zero, returning the nearest integral value that is not
|
2019-06-30 16:33:37 +03:00
|
|
|
// larger in magnitude than a.
|
2019-06-26 18:49:50 +03:00
|
|
|
pub fn trunc(a f64) f64 {
|
2019-06-23 09:19:37 +03:00
|
|
|
return C.trunc(a)
|
|
|
|
}
|