jyapayne/Nim
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Rewrote procs for float32/float64

Browse source 
When a proc is `importc`-ed, made explicit. Otherwise, used `[T: float32|float64]`
This commit is contained in:
apense 2015-06-24 16:09:18 -04:00
commit 35690dc37f
1 changed files with 128 additions and 86 deletions
Download patch file Download diff file Expand all files Collapse all files

140
lib/pure/math.nim
View file

@ -159,19 +159,26 @@ proc randomize*(seed: int) {.benign.}
{.push noSideEffect.} {.push noSideEffect.}
when not defined(JS): when not defined(JS):
proc sqrt*(x: float): float {.importc: "sqrt", header: "<math.h>".} proc sqrt*(x: float32): float32 {.importc: "sqrt", header: "<math.h>".}
proc sqrt*(x: float64): float64 {.importc: "sqrt", header: "<math.h>".}
## computes the square root of `x`. ## computes the square root of `x`.
proc cbrt*(x: float): float {.importc: "cbrt", header: "<math.h>".} proc cbrt*(x: float32): float32 {.importc: "cbrt", header: "<math.h>".}
proc cbrt*(x: float64): float64 {.importc: "cbrt", header: "<math.h>".}
## computes the cubic root of `x` ## computes the cubic root of `x`
proc ln*(x: float): float {.importc: "log", header: "<math.h>".} proc ln*(x: float32): float32 {.importc: "log", header: "<math.h>".}
proc ln*(x: float64): float64 {.importc: "log", header: "<math.h>".}
## computes ln(x). ## computes ln(x).
proc log10*(x: float): float {.importc: "log10", header: "<math.h>".} proc log10*(x: float32): float32 {.importc: "log10", header: "<math.h>".}
proc log2*(x: float): float = return ln(x) / ln(2.0) proc log10*(x: float64): float64 {.importc: "log10", header: "<math.h>".}
proc exp*(x: float): float {.importc: "exp", header: "<math.h>".} proc log2*[T: float32|float64](x: T): T = return ln(x) / ln(2.0)
proc exp*(x: float32): float32 {.importc: "exp", header: "<math.h>".}
proc exp*(x: float64): float64 {.importc: "exp", header: "<math.h>".}
## computes e**x. ## computes e**x.
proc frexp*(x: float, exponent: var int): float {. proc frexp*(x: float32, exponent: var int): float32 {.
importc: "frexp", header: "<math.h>".}
proc frexp*(x: float64, exponent: var int): float64 {.
importc: "frexp", header: "<math.h>".} importc: "frexp", header: "<math.h>".}
## Split a number into mantissa and exponent. ## Split a number into mantissa and exponent.
## `frexp` calculates the mantissa m (a float greater than or equal to 0.5 ## `frexp` calculates the mantissa m (a float greater than or equal to 0.5
@ -179,38 +186,55 @@ when not defined(JS):
## float value) equals m * 2**n. frexp stores n in `exponent` and returns ## float value) equals m * 2**n. frexp stores n in `exponent` and returns
## m. ## m.
proc round*(x: float): int {.importc: "lrint", header: "<math.h>".} proc round*(x: float32): int {.importc: "lrint", header: "<math.h>".}
proc round*(x: float64): int {.importc: "lrint", header: "<math.h>".}
## converts a float to an int by rounding. ## converts a float to an int by rounding.
proc arccos*(x: float): float {.importc: "acos", header: "<math.h>".} proc arccos*(x: float32): float32 {.importc: "acos", header: "<math.h>".}
proc arcsin*(x: float): float {.importc: "asin", header: "<math.h>".} proc arccos*(x: float64): float64 {.importc: "acos", header: "<math.h>".}
proc arctan*(x: float): float {.importc: "atan", header: "<math.h>".} proc arcsin*(x: float32): float32 {.importc: "asin", header: "<math.h>".}
proc arctan2*(y, x: float): float {.importc: "atan2", header: "<math.h>".} proc arcsin*(x: float64): float64 {.importc: "asin", header: "<math.h>".}
proc arctan*(x: float32): float32 {.importc: "atan", header: "<math.h>".}
proc arctan*(x: float64): float64 {.importc: "atan", header: "<math.h>".}
proc arctan2*(y, x: float32): float32 {.importc: "atan2", header: "<math.h>".}
proc arctan2*(y, x: float64): float64 {.importc: "atan2", header: "<math.h>".}
## Calculate the arc tangent of `y` / `x`. ## Calculate the arc tangent of `y` / `x`.
## `atan2` returns the arc tangent of `y` / `x`; it produces correct ## `atan2` returns the arc tangent of `y` / `x`; it produces correct
## results even when the resulting angle is near pi/2 or -pi/2 ## results even when the resulting angle is near pi/2 or -pi/2
## (`x` near 0). ## (`x` near 0).
proc cos*(x: float): float {.importc: "cos", header: "<math.h>".} proc cos*(x: float32): float32 {.importc: "cos", header: "<math.h>".}
proc cosh*(x: float): float {.importc: "cosh", header: "<math.h>".} proc cos*(x: float64): float64 {.importc: "cos", header: "<math.h>".}
proc hypot*(x, y: float): float {.importc: "hypot", header: "<math.h>".} proc cosh*(x: float32): float32 {.importc: "cosh", header: "<math.h>".}
proc cosh*(x: float64): float64 {.importc: "cosh", header: "<math.h>".}
proc hypot*(x, y: float32): float32 {.importc: "hypot", header: "<math.h>".}
proc hypot*(x, y: float64): float64 {.importc: "hypot", header: "<math.h>".}
## same as ``sqrt(x*x + y*y)``. ## same as ``sqrt(x*x + y*y)``.
proc sinh*(x: float): float {.importc: "sinh", header: "<math.h>".} proc sinh*(x: float32): float32 {.importc: "sinh", header: "<math.h>".}
proc sin*(x: float): float {.importc: "sin", header: "<math.h>".} proc sinh*(x: float64): float64 {.importc: "sinh", header: "<math.h>".}
proc tan*(x: float): float {.importc: "tan", header: "<math.h>".} proc sin*(x: float32): float32 {.importc: "sin", header: "<math.h>".}
proc tanh*(x: float): float {.importc: "tanh", header: "<math.h>".} proc sin*(x: float64): float64 {.importc: "sin", header: "<math.h>".}
proc pow*(x, y: float): float {.importc: "pow", header: "<math.h>".} proc tan*(x: float32): float32 {.importc: "tan", header: "<math.h>".}
proc tan*(x: float64): float64 {.importc: "tan", header: "<math.h>".}
proc tanh*(x: float32): float32 {.importc: "tanh", header: "<math.h>".}
proc tanh*(x: float64): float64 {.importc: "tanh", header: "<math.h>".}
proc pow*(x, y: float32): float32 {.importc: "pow", header: "<math.h>".}
proc pow*(x, y: float64): float64 {.importc: "pow", header: "<math.h>".}
## computes x to power raised of y. ## computes x to power raised of y.
proc erf*(x: float): float {.importc: "erf", header: "<math.h>".} proc erf*(x: float32): float32 {.importc: "erf", header: "<math.h>".}
proc erf*(x: float64): float64 {.importc: "erf", header: "<math.h>".}
## The error function ## The error function
proc erfc*(x: float): float {.importc: "erfc", header: "<math.h>".} proc erfc*(x: float32): float32 {.importc: "erfc", header: "<math.h>".}
proc erfc*(x: float64): float64 {.importc: "erfc", header: "<math.h>".}
## The complementary error function ## The complementary error function
proc lgamma*(x: float): float {.importc: "lgamma", header: "<math.h>".} proc lgamma*(x: float32): float32 {.importc: "lgamma", header: "<math.h>".}
proc lgamma*(x: float64): float64 {.importc: "lgamma", header: "<math.h>".}
## Natural log of the gamma function ## Natural log of the gamma function
proc tgamma*(x: float): float {.importc: "tgamma", header: "<math.h>".} proc tgamma*(x: float32): float32 {.importc: "tgamma", header: "<math.h>".}
proc tgamma*(x: float64): float64 {.importc: "tgamma", header: "<math.h>".}
## The gamma function ## The gamma function
# C procs: # C procs:
@ -263,16 +287,22 @@ when not defined(JS):
proc random(max: int): int = proc random(max: int): int =
result = int(rand()) mod max result = int(rand()) mod max
proc trunc*(x: float): float {.importc: "trunc", header: "<math.h>".} proc trunc*(x: float32): float32 {.importc: "trunc", header: "<math.h>".}
proc floor*(x: float): float {.importc: "floor", header: "<math.h>".} proc trunc*(x: float64): float64 {.importc: "trunc", header: "<math.h>".}
proc ceil*(x: float): float {.importc: "ceil", header: "<math.h>".} proc floor*(x: float32): float32 {.importc: "floor", header: "<math.h>".}
proc floor*(x: float64): float64 {.importc: "floor", header: "<math.h>".}
proc ceil*(x: float32): float32 {.importc: "ceil", header: "<math.h>".}
proc ceil*(x: float64): float64 {.importc: "ceil", header: "<math.h>".}
proc fmod*(x, y: float): float {.importc: "fmod", header: "<math.h>".} proc fmod*(x, y: float32): float32 {.importc: "fmod", header: "<math.h>".}
proc fmod*(x, y: float64): float64 {.importc: "fmod", header: "<math.h>".}
else: else:
proc mathrandom(): float {.importc: "Math.random", nodecl.} proc mathrandom(): float {.importc: "Math.random", nodecl.}
proc floor*(x: float): float {.importc: "Math.floor", nodecl.} proc floor*(x: float32): float32 {.importc: "Math.floor", nodecl.}
proc ceil*(x: float): float {.importc: "Math.ceil", nodecl.} proc floor*(x: float64): float64 {.importc: "Math.floor", nodecl.}
proc ceil*(x: float32): float32 {.importc: "Math.ceil", nodecl.}
proc ceil*(x: float64): float64 {.importc: "Math.ceil", nodecl.}
proc random(max: int): int = proc random(max: int): int =
result = int(floor(mathrandom() * float(max))) result = int(floor(mathrandom() * float(max)))
proc random(max: float): float = proc random(max: float): float =
@ -280,16 +310,20 @@ else:
proc randomize() = discard proc randomize() = discard
proc randomize(seed: int) = discard proc randomize(seed: int) = discard
proc sqrt*(x: float): float {.importc: "Math.sqrt", nodecl.} proc sqrt*(x: float32): float32 {.importc: "Math.sqrt", nodecl.}
proc ln*(x: float): float {.importc: "Math.log", nodecl.} proc sqrt*(x: float64): float64 {.importc: "Math.sqrt", nodecl.}
proc log10*(x: float): float = return ln(x) / ln(10.0) proc ln*(x: float32): float32 {.importc: "Math.log", nodecl.}
proc log2*(x: float): float = return ln(x) / ln(2.0) proc ln*(x: float64): float64 {.importc: "Math.log", nodecl.}
proc log10*[T: float32|float64](x: T): T = return ln(x) / ln(10.0)
proc log2*[T: float32|float64](x: T): T = return ln(x) / ln(2.0)
proc exp*(x: float): float {.importc: "Math.exp", nodecl.} proc exp*(x: float32): float32 {.importc: "Math.exp", nodecl.}
proc exp*(x: float64): float64 {.importc: "Math.exp", nodecl.}
proc round*(x: float): int {.importc: "Math.round", nodecl.} proc round*(x: float): int {.importc: "Math.round", nodecl.}
proc pow*(x, y: float): float {.importc: "Math.pow", nodecl.} proc pow*(x, y: float32): float32 {.importC: "Math.pow", nodecl.}
proc pow*(x, y: float64): float64 {.importc: "Math.pow", nodecl.}
proc frexp*(x: float, exponent: var int): float = proc frexp*[T: float32|float64](x: T, exponent: var int): T =
if x == 0.0: if x == 0.0:
exponent = 0 exponent = 0
result = 0.0 result = 0.0
@ -300,24 +334,32 @@ else:
exponent = round(ex) exponent = round(ex)
result = x / pow(2.0, ex) result = x / pow(2.0, ex)
proc arccos*(x: float): float {.importc: "Math.acos", nodecl.} proc arccos*(x: float32): float32 {.importc: "Math.acos", nodecl.}
proc arcsin*(x: float): float {.importc: "Math.asin", nodecl.} proc arccos*(x: float64): float64 {.importc: "Math.acos", nodecl.}
proc arctan*(x: float): float {.importc: "Math.atan", nodecl.} proc arcsin*(x: float32): float32 {.importc: "Math.asin", nodecl.}
proc arctan2*(y, x: float): float {.importc: "Math.atan2", nodecl.} proc arcsin*(x: float64): float64 {.importc: "Math.asin", nodecl.}
proc arctan*(x: float32): float32 {.importc: "Math.atan", nodecl.}
proc arctan*(x: float64): float64 {.importc: "Math.atan", nodecl.}
proc arctan2*(y, x: float32): float32 {.importC: "Math.atan2", nodecl.}
proc arctan2*(y, x: float64): float64 {.importc: "Math.atan2", nodecl.}
proc cos*(x: float): float {.importc: "Math.cos", nodecl.} proc cos*(x: float32): float32 {.importc: "Math.cos", nodecl.}
proc cosh*(x: float): float = return (exp(x)+exp(-x))*0.5 proc cos*(x: float64): float64 {.importc: "Math.cos", nodecl.}
proc hypot*(x, y: float): float = return sqrt(x*x + y*y) proc cosh*(x: float32): float32 = return (exp(x)+exp(-x))*0.5
proc sinh*(x: float): float = return (exp(x)-exp(-x))*0.5 proc cosh*(x: float64): float64 = return (exp(x)+exp(-x))*0.5
proc sin*(x: float): float {.importc: "Math.sin", nodecl.} proc hypot*[T: float32|float64](x, y: T): T = return sqrt(x*x + y*y)
proc tan*(x: float): float {.importc: "Math.tan", nodecl.} proc sinh*]T: float32|float64](x: T): T = return (exp(x)-exp(-x))*0.5
proc tanh*(x: float): float = proc sin*(x: float32): float32 {.importc: "Math.sin", nodecl.}
proc sin*(x: float64): float64 {.importc: "Math.sin", nodecl.}
proc tan*(x: float32): float32 {.importc: "Math.tan", nodecl.}
proc tan*(x: float64): float64 {.importc: "Math.tan", nodecl.}
proc tanh*[T: float32|float64](x: T): T =
var y = exp(2.0*x) var y = exp(2.0*x)
return (y-1.0)/(y+1.0) return (y-1.0)/(y+1.0)
{.pop.} {.pop.}
proc `mod`*(x, y: float): float = proc `mod`*[T: float32|float64](x, y: T): T =
## Computes the modulo operation for float operators. Equivalent ## Computes the modulo operation for float operators. Equivalent
## to ``x - y * floor(x/y)``. Note that the remainder will always ## to ``x - y * floor(x/y)``. Note that the remainder will always
## have the same sign as the divisor. ## have the same sign as the divisor.