Initial commit

Author: paked

LICENSE

@@ -0,0 +1,28 @@
+Copyright (c) 2012 The Go Author. All rights reserved.
+Copyright (c) 2015 The lux Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of the Google Inc., the Lux authors, nor the
+names of its contributors may be used to endorse or promote products
+derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,49 @@
+# math
+This library is a copy of the standard math library but for float32 (more common in computer graphics and games. Most of the function are simply casting the arguments as `float64` and forwarding to the original math library (something you would have to do anyway, but slowly we are translating the original function to the `float32` version.  
+ALL tests are passing, meaning whatever program you we're running using the 64 bit version should still be correct using this library (using the IEEE floating point definition of "correct").  
+I only care about i386 and amd64, but if I receive pull request for other architecture I will merge them (I can't test it so please send me proof that all test pass and benchmark are better :)
+
+## rewriten functions
+The benchmark is based on my macbook pro, with an i386 processor but a x86_64 operating system. benchmark may produce different results on different computers. However if you see an architecture for which casting to float64, calling the standard lib then casting back to flaot32 is faster then my implementation please tell me.  
+✓ = Test passing.  
+✗ = Not implemented yet.  
+? = Implemented but not tested.  
+\* = has no ASM implementation.
+
+
+|Abs|status|lux math|casting|std math|accel|  
+|---|---|---:|---:|---:|---:|  
+|function name|✓, ✗, ? or \* |benchmark for float32 using lux math package|benchmark for casting a var to float64, doing the op then casting back|benchmark for float64 using standard math package|accelleration between casting and lux math|
+
+|Abs|status|lux math|casting|std math|accel|  
+|---|---|---:|---:|---:|---:|
+|software|✓|||||
+|amd64|✓|2.10 ns/op|2.37 ns/op|2.08 ns/op|+13%|
+|386|✓|2.02 ns/op|2.24 ns/op|2.02 ns/op|+11%|
+
+|Sqrt|status|lux math|casting|std math|accel|
+|---|---|---:|---:|---:|---:|
+|software|✓|||||
+|amd64|✓|2.33 ns/op|4.70 ns/op|0.33 ns/op|+102%|
+|386|✓|2.33 ns/op|5.14 ns/op|4.74 ns/op|+121%|
+
+|Acosh|status|lux math|casting|std math|accel|  
+|---|---|---:|---:|---:|---:|  
+|software|✓|43.5 ns/op|75.8 ns/op|40.3 ns/op|+74%|
+
+|Asinh|status|lux math|casting|std math|accel|  
+|---|---|---:|---:|---:|---:|  
+|software|✓|47.3 ns/op|81.3 ns/op|46.1 ns/op|+72%|
+
+|Gamma|status|lux math|casting|std math|accel|  
+|---|---|---:|---:|---:|---:|  
+|software|✓|25.1 ns/op|38.5 ns/op|24.0 ns/op|+53%|
+
+
+|template|status|lux math|casting|std math|accel|  
+|---|---|---:|---:|---:|---:|  
+|software|✓| ns/op| ns/op| ns/op|%|
+|amd64|✓| ns/op| ns/op| ns/op|%|
+|i386|✓| ns/op| ns/op| ns/op|%|
+
+

abs.go

@@ -0,0 +1,26 @@
+// Copyright 2009 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package math
+
+// Abs returns the absolute value of x.
+//
+// Special cases are:
+//	Abs(±Inf) = +Inf
+//	Abs(NaN) = NaN
+func Abs(x float32) float32 {
+	if x < 0 {
+		return -x
+	}
+	if x == 0 {
+		return 0 // return correctly abs(-0)
+	}
+	return x
+}
+
+//func Abs(x float32) float32 //{ return float32(m.Abs(float64(x))) }
+
+// Note: the software version of abs is actually faster then the ASM version,
+// due to some inlining that doesn't happen with ASM, so we're just gonna remove
+// it for now.

acosh.go

@@ -0,0 +1,60 @@
+// Copyright 2010 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package math
+
+// The original C code, the long comment, and the constants
+// below are from FreeBSD's /usr/src/lib/msun/src/e_acosh.c
+// and came with this notice.  The go code is a simplified
+// version of the original C.
+//
+// ====================================================
+// Copyright (C) 1993 by Sun Microsystems, Inc. All rights reserved.
+//
+// Developed at SunPro, a Sun Microsystems, Inc. business.
+// Permission to use, copy, modify, and distribute this
+// software is freely granted, provided that this notice
+// is preserved.
+// ====================================================
+//
+//
+// __ieee754_acosh(x)
+// Method :
+//	Based on
+//	        acosh(x) = log [ x + sqrt(x*x-1) ]
+//	we have
+//	        acosh(x) := log(x)+ln2,	if x is large; else
+//	        acosh(x) := log(2x-1/(sqrt(x*x-1)+x)) if x>2; else
+//	        acosh(x) := log1p(t+sqrt(2.0*t+t*t)); where t=x-1.
+//
+// Special cases:
+//	acosh(x) is NaN with signal if x<1.
+//	acosh(NaN) is NaN without signal.
+//
+
+// Acosh returns the inverse hyperbolic cosine of x.
+//
+// Special cases are:
+//	Acosh(+Inf) = +Inf
+//	Acosh(x) = NaN if x < 1
+//	Acosh(NaN) = NaN
+func Acosh(x float32) float32 {
+	const (
+		Ln2   = 6.93147180559945286227e-01 // 0x3FE62E42FEFA39EF
+		Large = 1 << 28                    // 2**28
+	)
+	// first case is special case
+	switch {
+	case x < 1 || IsNaN(x):
+		return NaN()
+	case x == 1:
+		return 0
+	case x >= Large:
+		return Log(x) + Ln2 // x > 2**28
+	case x > 2:
+		return Log(2*x - 1/(x+Sqrt(x*x-1))) // 2**28 > x > 2
+	}
+	t := x - 1
+	return Log1p(t + Sqrt(2*t+t*t)) // 2 >= x > 1
+}