1
0
mirror of https://github.com/vlang/v.git synced 2023-08-10 21:13:21 +03:00
v/vlib/math/math.v
2020-10-15 15:42:16 +03:00

128 lines
2.9 KiB
V

// Copyright (c) 2019-2020 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
// NOTE
// When adding a new function, please make sure it's in the right place.
// All functions are sorted alphabetically, separated by wrapped functions vs
// backend specific functions.
// If using System/Backend dependent functions, put them in their respective
// .c.v or .js.v or other files
// Below are functions that are not wrappers for built-in system functions, but
// native V functions. They are still sorted alphabetically
// Faster approximate sin() and cos() implemented from lolremez
pub fn aprox_sin(a f64) f64 {
a0 := 1.91059300966915117e-31
a1 := 1.00086760103908896
a2 := -1.21276126894734565e-2
a3 := -1.38078780785773762e-1
a4 := -2.67353392911981221e-2
a5 := 2.08026600266304389e-2
a6 := -3.03996055049204407e-3
a7 := 1.38235642404333740e-4
return a0 + a * (a1 + a * (a2 + a * (a3 + a * (a4 + a * (a5 + a * (a6 + a * a7))))))
}
pub fn aprox_cos(a f64) f64 {
a0 := 9.9995999154986614e-1
a1 := 1.2548995793001028e-3
a2 := -5.0648546280678015e-1
a3 := 1.2942246466519995e-2
a4 := 2.8668384702547972e-2
a5 := 7.3726485210586547e-3
a6 := -3.8510875386947414e-3
a7 := 4.7196604604366623e-4
a8 := -1.8776444013090451e-5
return a0 + a * (a1 + a * (a2 + a * (a3 + a * (a4 + a * (a5 + a * (a6 + a * (a7 + a * a8)))))))
}
// copysign returns a value with the magnitude of x and the sign of y
pub fn copysign(x f64, y f64) f64 {
return f64_from_bits((f64_bits(x) & ~sign_mask) | (f64_bits(y) & sign_mask))
}
// degrees convert from degrees to radians.
pub fn degrees(radians f64) f64 {
return radians * (180.0 / pi)
}
// digits returns an array of the digits of n in the given base.
pub fn digits(_n int, base int) []int {
if base < 2 {
panic('digits: Cannot find digits of n with base $base')
}
mut n := _n
mut sign := 1
if n < 0 {
sign = -1
n = -n
}
mut res := []int{}
for n != 0 {
res << (n % base) * sign
n /= base
}
return res
}
pub fn fabs(x f64) f64 {
if x < 0.0 {
return -x
}
return x
}
// gcd calculates greatest common (positive) divisor (or zero if a and b are both zero).
pub fn gcd(a_ i64, b_ i64) i64 {
mut a := a_
mut b := b_
if a < 0 {
a = -a
}
if b < 0 {
b = -b
}
for b != 0 {
a %= b
if a == 0 {
return b
}
b %= a
}
return a
}
// lcm calculates least common (non-negative) multiple.
pub fn lcm(a i64, b i64) i64 {
if a == 0 {
return a
}
res := a * (b / gcd(b, a))
if res < 0 {
return -res
}
return res
}
// max returns the maximum value of the two provided.
pub fn max(a f64, b f64) f64 {
if a > b {
return a
}
return b
}
// min returns the minimum value of the two provided.
pub fn min(a f64, b f64) f64 {
if a < b {
return a
}
return b
}
// radians convert from radians to degrees.
pub fn radians(degrees f64) f64 {
return degrees * (pi / 180.0)
}