From 1570e613b51ddaac51aa97f0c8584efa2552603a Mon Sep 17 00:00:00 2001
From: playX <adel.prokurov@gmail.com>
Date: Fri, 20 Aug 2021 01:14:49 +0300
Subject: [PATCH] math: inf,nan,fmod for the JS backend (#11246)

---
 vlib/math/bits.c.v            |  12 +
 vlib/math/bits.js.v           |  18 +
 vlib/math/bits.v              |  11 -
 vlib/math/erf.v               | 659 ++++++++++++++++++++++++++++++++++
 vlib/math/erf_test.v          |  45 +++
 vlib/math/evaluate.v          |  18 +
 vlib/math/math.c.v            |   6 +-
 vlib/math/math.js.v           |  61 ++--
 vlib/v/gen/js/builtin_types.v |   1 +
 vlib/v/gen/js/js.v            |  15 +-
 10 files changed, 812 insertions(+), 34 deletions(-)
 create mode 100644 vlib/math/bits.c.v
 create mode 100644 vlib/math/bits.js.v
 create mode 100644 vlib/math/erf.v
 create mode 100644 vlib/math/erf_test.v
 create mode 100644 vlib/math/evaluate.v

diff --git a/vlib/math/bits.c.v b/vlib/math/bits.c.v
new file mode 100644
index 0000000000..27aab5eebc
--- /dev/null
+++ b/vlib/math/bits.c.v
@@ -0,0 +1,12 @@
+module math
+
+// inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
+pub fn inf(sign int) f64 {
+	v := if sign >= 0 { uvinf } else { uvneginf }
+	return f64_from_bits(v)
+}
+
+// nan returns an IEEE 754 ``not-a-number'' value.
+pub fn nan() f64 {
+	return f64_from_bits(uvnan)
+}
diff --git a/vlib/math/bits.js.v b/vlib/math/bits.js.v
new file mode 100644
index 0000000000..0bec945e21
--- /dev/null
+++ b/vlib/math/bits.js.v
@@ -0,0 +1,18 @@
+module math
+
+pub fn inf(sign int) f64 {
+	mut res := 0.0
+	if sign >= 0 {
+		#res.val = Infinity
+	} else {
+		#res.val = -Infinity
+	}
+	return res
+}
+
+pub fn nan() f64 {
+	mut res := 0.0
+	#res.val = NaN
+
+	return res
+}
diff --git a/vlib/math/bits.v b/vlib/math/bits.v
index 0626504bcc..dbf2237f85 100644
--- a/vlib/math/bits.v
+++ b/vlib/math/bits.v
@@ -15,17 +15,6 @@ const (
 	frac_mask = ((u64(1) << u64(shift)) - u64(1))
 )
 
-// inf returns positive infinity if sign >= 0, negative infinity if sign < 0.
-pub fn inf(sign int) f64 {
-	v := if sign >= 0 { math.uvinf } else { math.uvneginf }
-	return f64_from_bits(v)
-}
-
-// nan returns an IEEE 754 ``not-a-number'' value.
-pub fn nan() f64 {
-	return f64_from_bits(math.uvnan)
-}
-
 // is_nan reports whether f is an IEEE 754 ``not-a-number'' value.
 pub fn is_nan(f f64) bool {
 	// IEEE 754 says that only NaNs satisfy f != f.
diff --git a/vlib/math/erf.v b/vlib/math/erf.v
new file mode 100644
index 0000000000..043da317e8
--- /dev/null
+++ b/vlib/math/erf.v
@@ -0,0 +1,659 @@
+// Provides the [error](https://en.wikipedia.org/wiki/Error_function) and related functions
+// based on https://github.com/unovor/frame/blob/master/statrs-0.10.0/src/function/erf.rs
+//
+// NOTE: This impl does not have the same precision as glibc impl of erf,erfc and others, we should fix this
+// in the future.
+module math
+
+// Coefficients for erf_impl polynominal
+const (
+	// Polynomial coefficients for a numerator of `erf_impl`
+	// in the interval [1e-10, 0.5].
+	erf_impl_an     = [0.00337916709551257388990745, -0.00073695653048167948530905,
+		-0.374732337392919607868241, 0.0817442448733587196071743, -0.0421089319936548595203468,
+		0.0070165709512095756344528, -0.00495091255982435110337458, 0.000871646599037922480317225]
+	// Polynomial coefficients for a denominator of `erf_impl`
+	// in the interval [1e-10, 0.5]
+	erf_impl_ad     = [1.0, -0.218088218087924645390535, 0.412542972725442099083918,
+		-0.0841891147873106755410271, 0.0655338856400241519690695, -0.0120019604454941768171266,
+		0.00408165558926174048329689, -0.000615900721557769691924509]
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [0.5, 0.75].
+	erf_impl_bn     = [-0.0361790390718262471360258, 0.292251883444882683221149,
+		0.281447041797604512774415, 0.125610208862766947294894, 0.0274135028268930549240776,
+		0.00250839672168065762786937,
+	]
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [0.5, 0.75].
+	erf_impl_bd     = [1.0, 1.8545005897903486499845, 1.43575803037831418074962,
+		0.582827658753036572454135, 0.124810476932949746447682, 0.0113724176546353285778481]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [0.75, 1.25].
+	erf_impl_cn     = [
+		-0.0397876892611136856954425,
+		0.153165212467878293257683,
+		0.191260295600936245503129,
+		0.10276327061989304213645,
+		0.029637090615738836726027,
+		0.0046093486780275489468812,
+		0.000307607820348680180548455,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [0.75, 1.25].
+	erf_impl_cd     = [
+		1.0,
+		1.95520072987627704987886,
+		1.64762317199384860109595,
+		0.768238607022126250082483,
+		0.209793185936509782784315,
+		0.0319569316899913392596356,
+		0.00213363160895785378615014,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [1.25, 2.25].
+	erf_impl_dn     = [
+		-0.0300838560557949717328341,
+		0.0538578829844454508530552,
+		0.0726211541651914182692959,
+		0.0367628469888049348429018,
+		0.00964629015572527529605267,
+		0.00133453480075291076745275,
+		0.778087599782504251917881e-4,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [1.25, 2.25].
+	erf_impl_dd     = [
+		1.0,
+		1.75967098147167528287343,
+		1.32883571437961120556307,
+		0.552528596508757581287907,
+		0.133793056941332861912279,
+		0.0179509645176280768640766,
+		0.00104712440019937356634038,
+		-0.106640381820357337177643e-7,
+	]
+
+	//  Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [2.25, 3.5].
+	erf_impl_en     = [
+		-0.0117907570137227847827732,
+		0.014262132090538809896674,
+		0.0202234435902960820020765,
+		0.00930668299990432009042239,
+		0.00213357802422065994322516,
+		0.00025022987386460102395382,
+		0.120534912219588189822126e-4,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [2.25, 3.5].
+	erf_impl_ed     = [
+		1.0,
+		1.50376225203620482047419,
+		0.965397786204462896346934,
+		0.339265230476796681555511,
+		0.0689740649541569716897427,
+		0.00771060262491768307365526,
+		0.000371421101531069302990367,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [3.5, 5.25].
+	erf_impl_fn     = [
+		-0.00546954795538729307482955,
+		0.00404190278731707110245394,
+		0.0054963369553161170521356,
+		0.00212616472603945399437862,
+		0.000394984014495083900689956,
+		0.365565477064442377259271e-4,
+		0.135485897109932323253786e-5,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [3.5, 5.25].
+	erf_impl_fd     = [
+		1.0,
+		1.21019697773630784832251,
+		0.620914668221143886601045,
+		0.173038430661142762569515,
+		0.0276550813773432047594539,
+		0.00240625974424309709745382,
+		0.891811817251336577241006e-4,
+		-0.465528836283382684461025e-11,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [5.25, 8].
+	erf_impl_gn     = [
+		-0.00270722535905778347999196,
+		0.0013187563425029400461378,
+		0.00119925933261002333923989,
+		0.00027849619811344664248235,
+		0.267822988218331849989363e-4,
+		0.923043672315028197865066e-6,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [5.25, 8].
+	erf_impl_gd     = [
+		1.0,
+		0.814632808543141591118279,
+		0.268901665856299542168425,
+		0.0449877216103041118694989,
+		0.00381759663320248459168994,
+		0.000131571897888596914350697,
+		0.404815359675764138445257e-11,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [8, 11.5].
+	erf_impl_hn     = [
+		-0.00109946720691742196814323,
+		0.000406425442750422675169153,
+		0.000274499489416900707787024,
+		0.465293770646659383436343e-4,
+		0.320955425395767463401993e-5,
+		0.778286018145020892261936e-7,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [8, 11.5].
+	erf_impl_hd     = [
+		1.0,
+		0.588173710611846046373373,
+		0.139363331289409746077541,
+		0.0166329340417083678763028,
+		0.00100023921310234908642639,
+		0.24254837521587225125068e-4,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [11.5, 17].
+	erf_impl_in     = [
+		-0.00056907993601094962855594,
+		0.000169498540373762264416984,
+		0.518472354581100890120501e-4,
+		0.382819312231928859704678e-5,
+		0.824989931281894431781794e-7,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [11.5, 17].
+	erf_impl_id     = [
+		1.0,
+		0.339637250051139347430323,
+		0.043472647870310663055044,
+		0.00248549335224637114641629,
+		0.535633305337152900549536e-4,
+		-0.117490944405459578783846e-12,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [17, 24].
+	erf_impl_jn     = [
+		-0.000241313599483991337479091,
+		0.574224975202501512365975e-4,
+		0.115998962927383778460557e-4,
+		0.581762134402593739370875e-6,
+		0.853971555085673614607418e-8,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [17, 24].
+	erf_impl_jd     = [
+		1.0,
+		0.233044138299687841018015,
+		0.0204186940546440312625597,
+		0.000797185647564398289151125,
+		0.117019281670172327758019e-4,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [24, 38].
+	erf_impl_kn     = [
+		-0.000146674699277760365803642,
+		0.162666552112280519955647e-4,
+		0.269116248509165239294897e-5,
+		0.979584479468091935086972e-7,
+		0.101994647625723465722285e-8,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [24, 38].
+	erf_impl_kd     = [
+		1.0,
+		0.165907812944847226546036,
+		0.0103361716191505884359634,
+		0.000286593026373868366935721,
+		0.298401570840900340874568e-5,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [38, 60].
+	erf_impl_ln     = [
+		-0.583905797629771786720406e-4,
+		0.412510325105496173512992e-5,
+		0.431790922420250949096906e-6,
+		0.993365155590013193345569e-8,
+		0.653480510020104699270084e-10,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [38, 60].
+	erf_impl_ld     = [
+		1.0,
+		0.105077086072039915406159,
+		0.00414278428675475620830226,
+		0.726338754644523769144108e-4,
+		0.477818471047398785369849e-6,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [60, 85].
+	erf_impl_mn     = [
+		-0.196457797609229579459841e-4,
+		0.157243887666800692441195e-5,
+		0.543902511192700878690335e-7,
+		0.317472492369117710852685e-9,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [60, 85].
+	erf_impl_md     = [
+		1.0,
+		0.052803989240957632204885,
+		0.000926876069151753290378112,
+		0.541011723226630257077328e-5,
+		0.535093845803642394908747e-15,
+	]
+
+	// Polynomial coefficients for a numerator in `erf_impl`
+	// in the interval [85, 110].
+	erf_impl_nn     = [
+		-0.789224703978722689089794e-5,
+		0.622088451660986955124162e-6,
+		0.145728445676882396797184e-7,
+		0.603715505542715364529243e-10,
+	]
+
+	// Polynomial coefficients for a denominator in `erf_impl`
+	// in the interval [85, 110].
+	erf_impl_nd     = [
+		1.0,
+		0.0375328846356293715248719,
+		0.000467919535974625308126054,
+		0.193847039275845656900547e-5,
+	]
+
+	// **********************************************************
+	// ********** Coefficients for erf_inv_impl polynomial ******
+	// **********************************************************
+	// Polynomial coefficients for a numerator of `erf_inv_impl`
+	// in the interval [0, 0.5].
+	erf_inv_impl_an = [
+		-0.000508781949658280665617,
+		-0.00836874819741736770379,
+		0.0334806625409744615033,
+		-0.0126926147662974029034,
+		-0.0365637971411762664006,
+		0.0219878681111168899165,
+		0.00822687874676915743155,
+		-0.00538772965071242932965,
+	]
+
+	// Polynomial coefficients for a denominator of `erf_inv_impl`
+	// in the interval [0, 0.5].
+	erf_inv_impl_ad = [
+		1.0,
+		-0.970005043303290640362,
+		-1.56574558234175846809,
+		1.56221558398423026363,
+		0.662328840472002992063,
+		-0.71228902341542847553,
+		-0.0527396382340099713954,
+		0.0795283687341571680018,
+		-0.00233393759374190016776,
+		0.000886216390456424707504,
+	]
+
+	// Polynomial coefficients for a numerator of `erf_inv_impl`
+	// in the interval [0.5, 0.75].
+	erf_inv_impl_bn = [
+		-0.202433508355938759655,
+		0.105264680699391713268,
+		8.37050328343119927838,
+		17.6447298408374015486,
+		-18.8510648058714251895,
+		-44.6382324441786960818,
+		17.445385985570866523,
+		21.1294655448340526258,
+		-3.67192254707729348546,
+	]
+
+	// Polynomial coefficients for a denominator of `erf_inv_impl`
+	// in the interval [0.5, 0.75].
+	erf_inv_impl_bd = [
+		1.0,
+		6.24264124854247537712,
+		3.9713437953343869095,
+		-28.6608180499800029974,
+		-20.1432634680485188801,
+		48.5609213108739935468,
+		10.8268667355460159008,
+		-22.6436933413139721736,
+		1.72114765761200282724,
+	]
+
+	// Polynomial coefficients for a numerator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x less than 3.
+	erf_inv_impl_cn = [
+		-0.131102781679951906451,
+		-0.163794047193317060787,
+		0.117030156341995252019,
+		0.387079738972604337464,
+		0.337785538912035898924,
+		0.142869534408157156766,
+		0.0290157910005329060432,
+		0.00214558995388805277169,
+		-0.679465575181126350155e-6,
+		0.285225331782217055858e-7,
+		-0.681149956853776992068e-9,
+	]
+
+	// Polynomial coefficients for a denominator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x less than 3.
+	erf_inv_impl_cd = [
+		1.0,
+		3.46625407242567245975,
+		5.38168345707006855425,
+		4.77846592945843778382,
+		2.59301921623620271374,
+		0.848854343457902036425,
+		0.152264338295331783612,
+		0.01105924229346489121,
+	]
+
+	// Polynomial coefficients for a numerator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x between 3 and 6.
+	erf_inv_impl_dn = [
+		-0.0350353787183177984712,
+		-0.00222426529213447927281,
+		0.0185573306514231072324,
+		0.00950804701325919603619,
+		0.00187123492819559223345,
+		0.000157544617424960554631,
+		0.460469890584317994083e-5,
+		-0.230404776911882601748e-9,
+		0.266339227425782031962e-11,
+	]
+
+	// Polynomial coefficients for a denominator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x between 3 and 6.
+	erf_inv_impl_dd = [
+		1.0,
+		1.3653349817554063097,
+		0.762059164553623404043,
+		0.220091105764131249824,
+		0.0341589143670947727934,
+		0.00263861676657015992959,
+		0.764675292302794483503e-4,
+	]
+
+	// Polynomial coefficients for a numerator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x between 6 and 18.
+	erf_inv_impl_en = [
+		-0.0167431005076633737133,
+		-0.00112951438745580278863,
+		0.00105628862152492910091,
+		0.000209386317487588078668,
+		0.149624783758342370182e-4,
+		0.449696789927706453732e-6,
+		0.462596163522878599135e-8,
+		-0.281128735628831791805e-13,
+		0.99055709973310326855e-16,
+	]
+
+	// Polynomial coefficients for a denominator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x between 6 and 18.
+	erf_inv_impl_ed = [
+		1.0,
+		0.591429344886417493481,
+		0.138151865749083321638,
+		0.0160746087093676504695,
+		0.000964011807005165528527,
+		0.275335474764726041141e-4,
+		0.282243172016108031869e-6,
+	]
+
+	// Polynomial coefficients for a numerator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x between 18 and 44.
+	erf_inv_impl_fn = [
+		-0.0024978212791898131227,
+		-0.779190719229053954292e-5,
+		0.254723037413027451751e-4,
+		0.162397777342510920873e-5,
+		0.396341011304801168516e-7,
+		0.411632831190944208473e-9,
+		0.145596286718675035587e-11,
+		-0.116765012397184275695e-17,
+	]
+
+	// Polynomial coefficients for a denominator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x between 18 and 44.
+	erf_inv_impl_fd = [
+		1.0,
+		0.207123112214422517181,
+		0.0169410838120975906478,
+		0.000690538265622684595676,
+		0.145007359818232637924e-4,
+		0.144437756628144157666e-6,
+		0.509761276599778486139e-9,
+	]
+
+	// Polynomial coefficients for a numerator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x greater than 44.
+	erf_inv_impl_gn = [
+		-0.000539042911019078575891,
+		-0.28398759004727721098e-6,
+		0.899465114892291446442e-6,
+		0.229345859265920864296e-7,
+		0.225561444863500149219e-9,
+		0.947846627503022684216e-12,
+		0.135880130108924861008e-14,
+		-0.348890393399948882918e-21,
+	]
+
+	// Polynomial coefficients for a denominator of `erf_inv_impl`
+	// in the interval [0.75, 1] with x greater than 44.
+	erf_inv_impl_gd = [
+		1.0,
+		0.0845746234001899436914,
+		0.00282092984726264681981,
+		0.468292921940894236786e-4,
+		0.399968812193862100054e-6,
+		0.161809290887904476097e-8,
+		0.231558608310259605225e-11,
+	]
+)
+
+fn erf_inv_impl(p f64, q f64, s f64) f64 {
+	mut result := 0.0
+	if p <= 0.5 {
+		y := 0.0891314744949340820313
+		g := p * (p + 10.0)
+		r := polynomial(p, math.erf_inv_impl_an) / polynomial(p, math.erf_inv_impl_ad)
+		result = g * y + g * r
+	} else if q >= 0.25 {
+		y := 2.249481201171875
+		g := sqrt(-2.0 * log(q))
+		xs := q - 0.25
+		r := polynomial(xs, math.erf_inv_impl_bn) / polynomial(xs, math.erf_inv_impl_bd)
+		result = g / (y + r)
+	} else {
+		x := sqrt(-log(q))
+		if x < 3.0 {
+			y := 0.807220458984375
+			xs := x - 1.125
+			r := polynomial(xs, math.erf_inv_impl_cn) / polynomial(xs, math.erf_inv_impl_cd)
+			result = y * x + r * x
+		} else if x < 6.0 {
+			y := 0.93995571136474609375
+			xs := x - 3.0
+			r := polynomial(xs, math.erf_inv_impl_dn) / polynomial(xs, math.erf_inv_impl_dd)
+			result = y * x + r * x
+		} else if x < 18.0 {
+			y := 0.98362827301025390625
+			xs := x - 6.0
+			r := polynomial(xs, math.erf_inv_impl_en) / polynomial(xs, math.erf_inv_impl_ed)
+			result = y * x + r * x
+		} else if x < 44.0 {
+			y := 0.99714565277099609375
+			xs := x - 18.0
+			r := polynomial(xs, math.erf_inv_impl_fn) / polynomial(xs, math.erf_inv_impl_fd)
+			result = y * x + r * x
+		} else {
+			y := 0.99941349029541015625
+			xs := x - 44.0
+			r := polynomial(xs, math.erf_inv_impl_gn) / polynomial(xs, math.erf_inv_impl_gd)
+			result = y * x + r * x
+		}
+	}
+
+	return s * result
+}
+
+fn erf_impl(z f64, inv bool) f64 {
+	if z < 0.0 {
+		if !inv {
+			return -erf_impl(-z, false)
+		}
+		if z < -0.5 {
+			return 2.0 - erf_impl(-z, true)
+		}
+		return 1.0 + erf_impl(-z, false)
+	}
+	mut result := 0.0
+	if z < 0.5 {
+		if z < 1e-10 {
+			result = z * 1.125 + z * 0.003379167095512573896158903121545171688
+		} else {
+			result = z * 1.125 +
+				z * polynomial(z, math.erf_impl_an) / polynomial(z, math.erf_impl_ad)
+		}
+	} else if z < 110.0 {
+		mut r := 0.0
+		mut b := 0.0
+		if z < 0.75 {
+			r = polynomial(z - 0.5, math.erf_impl_bn) / polynomial(z - 0.5, math.erf_impl_bd)
+			b = 0.3440242112
+		} else if z < 1.25 {
+			r = polynomial(z - 0.75, math.erf_impl_cn) / polynomial(z - 0.75, math.erf_impl_cd)
+			b = 0.419990927
+		} else if z < 2.25 {
+			r = polynomial(z - 1.25, math.erf_impl_dn) / polynomial(z - 1.25, math.erf_impl_dd)
+			b = 0.4898625016
+		} else if z < 3.5 {
+			r = polynomial(z - 2.25, math.erf_impl_en) / polynomial(z - 2.25, math.erf_impl_ed)
+			b = 0.5317370892
+		} else if z < 5.25 {
+			r = polynomial(z - 3.5, math.erf_impl_fn) / polynomial(z - 3.5, math.erf_impl_fd)
+			b = 0.5489973426
+		} else if z < 8.0 {
+			r = polynomial(z - 5.25, math.erf_impl_gn) / polynomial(z - 5.25, math.erf_impl_gd)
+			b = 0.5571740866
+		} else if z < 11.5 {
+			r = polynomial(z - 8.0, math.erf_impl_hn) / polynomial(z - 8.0, math.erf_impl_hd)
+			b = 0.5609807968
+		} else if z < 17.0 {
+			r = polynomial(z - 11.5, math.erf_impl_in) / polynomial(z - 11.5, math.erf_impl_id)
+			b = 0.5626493692
+		} else if z < 24.0 {
+			r = polynomial(z - 17.0, math.erf_impl_jn) / polynomial(z - 17.0, math.erf_impl_jd)
+			b = 0.5634598136
+		} else if z < 38.0 {
+			r = polynomial(z - 24.0, math.erf_impl_kn) / polynomial(z - 24.0, math.erf_impl_kd)
+			b = 0.5638477802
+		} else if z < 60.0 {
+			r = polynomial(z - 38.0, math.erf_impl_ln) / polynomial(z - 38.0, math.erf_impl_ld)
+			b = 0.5640528202
+		} else if z < 85.0 {
+			r = polynomial(z - 60.0, math.erf_impl_mn) / polynomial(z - 60.0, math.erf_impl_md)
+			b = 0.5641309023
+		} else {
+			r = polynomial(z - 85.0, math.erf_impl_nn) / polynomial(z - 85.0, math.erf_impl_nd)
+			b = 0.5641584396
+		}
+
+		g := exp(-z * z) / z
+		result = g * b + g * r
+	} else {
+		result = 0.0
+	}
+	if inv && z >= 0.5 {
+		return result
+	} else if z >= 0.5 || inv {
+		return 1.0 - result
+	} else {
+		return result
+	}
+}
+
+/// 'erf' calculates the error function at `x`.
+pub fn erf(x f64) f64 {
+	if is_nan(x) {
+		return nan()
+	} else if is_inf(x, 1) {
+		return 1.0
+	} else if is_inf(x, -1) {
+		return -1.0
+	} else if x == 0.0 {
+		return 0.0
+	} else {
+		return erf_impl(x, false)
+	}
+}
+
+// `erf_inv` calculates the inverse error function at `x`.
+pub fn erf_inv(x f64) f64 {
+	if x == 0 {
+		return 0.0
+	} else if x >= 1.0 {
+		return inf(1)
+	} else if x <= -1.0 {
+		return inf(-1)
+	} else if x < 0.0 {
+		return erf_inv_impl(-x, 1.0 + x, -1.0)
+	} else {
+		return erf_inv_impl(x, 1.0 - x, 1.0)
+	}
+}
+
+// `erfc` calculates the complementary error function at `x`.
+pub fn erfc(x f64) f64 {
+	if is_nan(x) {
+		return nan()
+	} else if is_inf(x, 1) {
+		return 0.0
+	} else if is_inf(x, -1) {
+		return 2.0
+	} else {
+		return erf_impl(x, true)
+	}
+}
+
+// `erfc_inv` calculates the complementary inverse error function at `x`.
+pub fn erfc_inv(x f64) f64 {
+	if x <= 0.0 {
+		return inf(1)
+	} else if x >= 2.0 {
+		return inf(-1)
+	} else if is_inf(x, -1) {
+		return erf_inv_impl(-1.0 + x, 2.0 - x, -1.0)
+	} else {
+		return erf_inv_impl(1.0 - x, x, 1.0)
+	}
+}
diff --git a/vlib/math/erf_test.v b/vlib/math/erf_test.v
new file mode 100644
index 0000000000..00cedb916a
--- /dev/null
+++ b/vlib/math/erf_test.v
@@ -0,0 +1,45 @@
+import math
+
+fn almost_eq(a f64, b f64, acc f64) bool {
+	if math.is_inf(a, 1) || math.is_inf(a, -1) || math.is_inf(b, 1) || math.is_inf(b, -1) {
+		return a == b
+	}
+
+	if math.is_nan(a) || math.is_nan(b) {
+		return false
+	}
+
+	return math.abs(a - b) < acc
+}
+
+fn test_erf() {
+	assert math.is_nan(math.erf(math.nan()))
+	assert almost_eq(math.erf(-1.0), -0.8427007888650501, 1e-11)
+	assert math.erf(0.0) == 0.0
+	assert math.erf(1e-15) == 0.0000000000000011283791670955126615773132947717431253912942469337536
+	assert math.erf(0.1) == 0.11246291601917208
+	assert math.erf(0.3) == 0.32862677677789676
+	assert almost_eq(math.erf(0.5), 0.5204998778130465376827466538919645287364515757579637,
+		1e-9)
+	assert math.erf(1.0) == 0.8427007888650501
+	assert math.erf(1.5) == 0.966105146259005
+	assert math.erf(6.0) == 0.99999999999999997848026328750108688340664960081261537
+	assert math.erf(5.0) == 0.99999999999846254020557196514981165651461662110988195
+	assert math.erf(4.0) == 0.999999984582742
+	assert math.erf(math.inf(1)) == 1.0
+	assert math.erf(math.inf(-1)) == -1.0
+}
+
+fn test_erfc() {
+	assert almost_eq(math.erfc(-1.0), 1.84270078886505, 1e-11)
+	assert math.erfc(0.0) == 1.0
+	assert math.erfc(0.1) == 0.8875370839808279
+	assert math.erfc(0.2) == 0.7772974103342554
+}
+
+fn test_erfc_inv() {
+	assert math.erfc_inv(0.0) == math.inf(1)
+	assert math.erfc_inv(1e-100) == 15.060286697120752
+	assert math.erfc_inv(1.0) == 0.0
+	assert math.erfc_inv(0.5) == 0.47660913088024937
+}
diff --git a/vlib/math/evaluate.v b/vlib/math/evaluate.v
new file mode 100644
index 0000000000..5512208b77
--- /dev/null
+++ b/vlib/math/evaluate.v
@@ -0,0 +1,18 @@
+module math
+
+// Provides functions that don't have a numerical solution and must
+// be solved computationally (e.g. evaluation of a polynomial)
+
+pub fn polynomial(z f64, coeff []f64) f64 {
+	n := coeff.len
+	if n == 0 {
+		return 0.0
+	}
+
+	mut sum := coeff[n - 1]
+	for i := n - 1; i >= 0; i-- {
+		sum *= z
+		sum += coeff[i]
+	}
+	return sum
+}
diff --git a/vlib/math/math.c.v b/vlib/math/math.c.v
index 689e648691..5d605d80c7 100644
--- a/vlib/math/math.c.v
+++ b/vlib/math/math.c.v
@@ -150,18 +150,20 @@ pub fn exp(a f64) f64 {
 	return C.exp(a)
 }
 
+/*
 // erf computes the error function value
 [inline]
 pub fn erf(a f64) f64 {
 	return C.erf(a)
 }
-
+*/
+/*
 // erfc computes the complementary error function value
 [inline]
 pub fn erfc(a f64) f64 {
 	return C.erfc(a)
 }
-
+*/
 // exp2 returns the base-2 exponential function of a (math.pow(2, a)).
 [inline]
 pub fn exp2(a f64) f64 {
diff --git a/vlib/math/math.js.v b/vlib/math/math.js.v
index 437e8ab057..3c8ce8de92 100644
--- a/vlib/math/math.js.v
+++ b/vlib/math/math.js.v
@@ -111,25 +111,17 @@ pub fn cosh(a f64) f64 {
 // exp calculates exponent of the number (math.pow(math.E, a)).
 [inline]
 pub fn exp(a f64) f64 {
-	return JS.Math.exp(a)
-}
+	mut res := 0.0
+	#res.val = Math.exp(a)
 
-// erf computes the error function value
-[inline]
-pub fn erf(a f64) f64 {
-	return JS.Math.erf(a)
-}
-
-// erfc computes the complementary error function value
-[inline]
-pub fn erfc(a f64) f64 {
-	return JS.Math.erfc(a)
+	return res
 }
 
 // exp2 returns the base-2 exponential function of a (math.pow(2, a)).
 [inline]
 pub fn exp2(a f64) f64 {
-	return JS.Math.exp2(a)
+	return 0
+	// return JS.Math.exp2(a)
 }
 
 // floor returns the nearest f64 lower or equal of the provided value.
@@ -140,20 +132,46 @@ pub fn floor(a f64) f64 {
 
 // fmod returns the floating-point remainder of number / denom (rounded towards zero):
 [inline]
-pub fn fmod(a f64, b f64) f64 {
-	return JS.Math.fmod(a, b)
+pub fn fmod(x f64, y f64) f64 {
+	#let tmp
+	#let tmp2
+	#let p = 0
+	#let pY = 0
+	#let l = 0.0
+	#let l2 = 0.0
+	#tmp = x.toExponential().match(/^.\.?(.*)e(.+)$/)
+	#p = parseInt(tmp[2], 10) - (tmp[1] + '').length
+	#tmp = y.toExponential().match(/^.\.?(.*)e(.+)$/)
+	#pY = parseInt(tmp[2], 10) - (tmp[1] + '').length
+	#if (pY > p) {
+	#p = pY
+	#}
+	#tmp2 = (x % y)
+	#if (p < -100 || p > 20) {
+	// toFixed will give an out of bound error so we fix it like this:
+	#l = Math.round(Math.log(tmp2) / Math.log(10))
+	#l2 = Math.pow(10, l)
+	#return new builtin.f64((tmp2 / l2).toFixed(l - p) * l2)
+	#} else {
+	#return new builtin.f64(parseFloat(tmp2.toFixed(-p)))
+	#}
+
+	return 0.0
+	// return JS.Math.fmod(a, b)
 }
 
 // gamma computes the gamma function value
 [inline]
 pub fn gamma(a f64) f64 {
-	return JS.Math.tgamma(a)
+	return 0
+	//	return JS.Math.tgamma(a)
 }
 
 // Returns hypotenuse of a right triangle.
 [inline]
 pub fn hypot(a f64, b f64) f64 {
-	return JS.Math.hypot(a, b)
+	return 0
+	// return JS.Math.hypot(a, b)
 }
 
 // log calculates natural (base-e) logarithm of the provided value.
@@ -165,19 +183,22 @@ pub fn log(a f64) f64 {
 // log2 calculates base-2 logarithm of the provided value.
 [inline]
 pub fn log2(a f64) f64 {
-	return JS.Math.log2(a)
+	return 0
+	// return JS.Math.log2(a)
 }
 
 // log10 calculates the common (base-10) logarithm of the provided value.
 [inline]
 pub fn log10(a f64) f64 {
-	return JS.Math.log10(a)
+	return 0.0
+	// return JS.Math.log10(a)
 }
 
 // log_gamma computes the log-gamma function value
 [inline]
 pub fn log_gamma(a f64) f64 {
-	return JS.Math.lgamma(a)
+	return 0
+	// return JS.Math.lgamma(a)
 }
 
 // log_n calculates base-N logarithm of the provided value.
diff --git a/vlib/v/gen/js/builtin_types.v b/vlib/v/gen/js/builtin_types.v
index e9ce2fadaa..80a96a30aa 100644
--- a/vlib/v/gen/js/builtin_types.v
+++ b/vlib/v/gen/js/builtin_types.v
@@ -348,6 +348,7 @@ fn (mut g JsGen) gen_builtin_type_defs() {
 			'f32', 'f64', 'float_literal' {
 				g.gen_builtin_prototype(
 					typ_name: typ_name
+					constructor: 'this.val = +val'
 					default_value: 'new Number(0)'
 					to_jsval: '+this'
 				)
diff --git a/vlib/v/gen/js/js.v b/vlib/v/gen/js/js.v
index f727a15792..58d128e111 100644
--- a/vlib/v/gen/js/js.v
+++ b/vlib/v/gen/js/js.v
@@ -1921,7 +1921,18 @@ fn (mut g JsGen) gen_infix_expr(it ast.InfixExpr) {
 		}
 		return
 	}
-	if it.op == .eq || it.op == .ne {
+	if it.op == .logical_or || it.op == .and {
+		if g.ns.name == 'builtin' {
+			g.write('new ')
+		}
+		g.write('bool(')
+		g.expr(it.left)
+		g.write('.valueOf()')
+		g.write(it.op.str())
+		g.expr(it.right)
+		g.write('.valueOf()')
+		g.write(')')
+	} else if it.op == .eq || it.op == .ne {
 		has_operator_overloading := g.table.type_has_method(l_sym, '==')
 		if has_operator_overloading {
 			g.expr(it.left)
@@ -2063,10 +2074,12 @@ fn (mut g JsGen) gen_infix_expr(it ast.InfixExpr) {
 
 			g.expr(it.left)
 			g.gen_deref_ptr(it.left_type)
+			// g.write('.val')
 			g.write(' $it.op ')
 
 			g.expr(it.right)
 			g.gen_deref_ptr(it.right_type)
+			// g.write('.val')
 
 			if is_arithmetic {
 				g.cast_stack.delete_last()