vectormath.py

from math import sqrt, sin, cos, tan, pi, acos, asin, atan, atan2, pow as powf, exp, log, e, frexp, ldexp
from rpython.rlib.rfloat import INFINITY, NAN, DBL_MIN, DBL_MAX, DBL_EPSILON
from rpython.rtyper.lltypesystem import rffi
from rpython.rlib.rrandom import Random
from rpython.rlib.rarithmetic import r_uint, r_ulonglong
from space import *
import time

abs_ = Multimethod(1)
length = Multimethod(1)
#distance = Multimethod(2)
dot = Multimethod(2)
cross = Multimethod(2)
normalize = Multimethod(1)
#reflect = Multimethod(2)
#refract = Multimethod(3)
pow_ = Multimethod(2)
operators.coerce_by_default(pow_)

class Vec3(Object):
    __slots__ = ['x', 'y', 'z']
    _immutable_fields_ = ['x', 'y', 'z']
    def __init__(self, x, y, z):
        self.x = x
        self.y = y
        self.z = z

    def getattr(self, name):
        if name == u"x":
            return Float(self.x)
        if name == u"y":
            return Float(self.y)
        if name == u"z":
            return Float(self.z)
        if name == u"length":
            return Integer(3)
        return Object.getattr(self, name)

    def iter(self):
        return List([Float(self.x), Float(self.y), Float(self.z)]).iter()

    def repr(self):
        return u"vec3(%f, %f, %f)" % (self.x, self.y, self.z)

@Vec3.instantiator
def _(argv):
    if len(argv) > 3:
        raise OldError(u"Too many arguments to vec3")
    xyz = [0.0, 0.0, 0.0]
    for i, arg in enumerate(argv):
        xyz[i] = to_float(arg)
    return Vec3(xyz[0], xyz[1], xyz[2])

@operators.add.multimethod_s(Vec3, Vec3)
def _(self, other):
    return Vec3(self.x + other.x, self.y + other.y, self.z + other.z)

@operators.sub.multimethod_s(Vec3, Vec3)
def _(self, other):
    return Vec3(self.x - other.x, self.y - other.y, self.z - other.z)

@operators.mul.multimethod_s(Vec3, Float)
def _(self, s):
    return Vec3(self.x * s.number, self.y * s.number, self.z * s.number)

@operators.mul.multimethod_s(Float, Vec3)
def _(s, self):
    return Vec3(s.number * self.x, s.number * self.y, s.number * self.z)

@operators.div.multimethod_s(Vec3, Float)
def _(self, s):
    return Vec3(self.x / s.number, self.y / s.number, self.z / s.number)

@operators.div.multimethod_s(Float, Vec3)
def _(s, self):
    return Vec3(s.number / self.x, s.number / self.y, s.number / self.z)

@length.multimethod_s(Vec3)
def _(v):
    x, y, z = v.x, v.y, v.z
    return Float(sqrt(x*x + y*y + z*z))

#def distance(a, b):
#    return length(a - b)

@dot.multimethod_s(Vec3, Vec3)
def _(a, b):
    x0, y0, z0 = a.x, a.y, a.z
    x1, y1, z1 = b.x, b.y, b.z
    return Float(x0*x1 + y0*y1 + z0*z1)

@cross.multimethod_s(Vec3, Vec3)
def _(a, b):
    x0, y0, z0 = a.x, a.y, a.z
    x1, y1, z1 = b.x, b.y, b.z
    return Vec3(y0*z1 - z0*y1, z0*x1 - x0*z1, x0*y1 - y0*x1)

@normalize.multimethod_s(Vec3)
def _(v):
    x, y, z = v.x, v.y, v.z
    d = sqrt(x*x + y*y + z*z)
    if d > 0.0:
        return Vec3(v.x / d, v.y / d, v.z / d)
    return v

#def reflect(i, n):
#    return i - 2.0 * dot(n, i) * n
#
#def refract(i, n, eta):
#    ni = dot(n, i)
#    k = 1.0 - eta * eta * (1.0 - ni*ni)
#    return 0.0 if k < 0.0 else eta * i - (eta * ni + sqrt(k)) * n

class Quat(Object):
    __slots__ = ['x', 'y', 'z', 'w']
    _immutable_fields_ = ['x', 'y', 'z', 'w']
    def __init__(self, x, y, z, w):
        self.x = x
        self.y = y
        self.z = z
        self.w = w

    def getattr(self, name):
        if name == u"x":
            return Float(self.x)
        if name == u"y":
            return Float(self.y)
        if name == u"z":
            return Float(self.z)
        if name == u"w":
            return Float(self.w)
        if name == u"length":
            return Integer(4)
        return Object.getattr(self, name)

    def iter(self):
        return List([Float(self.x), Float(self.y), Float(self.z), Float(self.w)]).iter()

@Quat.instantiator
def _(argv):
    if len(argv) > 4:
        raise OldError(u"Too many arguments to quat")
    xyz = [0.0, 0.0, 0.0, 1.0]
    for i, arg in enumerate(argv):
        xyz[i] = to_float(arg)
    return Quat(xyz[0], xyz[1], xyz[2], xyz[3])

@Quat.builtin_method
def to_mat4(argv):
    if len(argv) < 1:
        raise OldError(u"Too few arguments")
    q = argv[0]
    if not isinstance(q, Quat):
        raise OldError(u"Expected quaternion")
    if len(argv) > 1:
        p = argv[1]
        if not isinstance(p, Vec3):
            raise OldError(u"Expected vec3 as argument")
        x, y, z = p.x, p.y, p.z
    else:
        x = y = z = 0.0
    sqx = q.x*q.x
    sqy = q.y*q.y
    sqz = q.z*q.z
    sqw = q.w*q.w
    # inverse only required if quaternion not normalized
    invs = 1 / (sqx + sqy + sqz + sqw)
    m00 = ( sqx - sqy - sqz + sqw)*invs
    m11 = (-sqx + sqy - sqz + sqw)*invs
    m22 = (-sqx - sqy + sqz + sqw)*invs
    tmp1 = q.x*q.y
    tmp2 = q.z*q.w
    m10 = 2.0 * (tmp1 + tmp2)*invs
    m01 = 2.0 * (tmp1 - tmp2)*invs
    tmp1 = q.x*q.z
    tmp2 = q.y*q.w
    m20 = 2.0 * (tmp1 - tmp2)*invs
    m02 = 2.0 * (tmp1 + tmp2)*invs
    tmp1 = q.y*q.z
    tmp2 = q.x*q.w
    m21 = 2.0 * (tmp1 + tmp2)*invs
    m12 = 2.0 * (tmp1 - tmp2)*invs
    return Mat4([
        m00, m10, m20, 0.0,
        m01, m11, m21, 0.0,
        m02, m12, m22, 0.0,
        x,   y,   z,   1.0])
    


@Quat.builtin_method
@signature(Quat)
def invert(self):
    dot = sqrt(self.x*self.x + self.y*self.y + self.z*self.z + self.w*self.w)
    invDot = 1.0 / dot if dot > 0.0 else 0.0
    return Quat(-self.x*invDot, -self.y*invDot, -self.z*invDot, self.w*invDot)

@operators.neg.multimethod_s(Vec3)
def _(self):
    return Vec3(-self.x, -self.y, -self.z)

@operators.neg.multimethod_s(Quat)
def _(self):
    return Quat(-self.x, -self.y, -self.z, self.w)

@operators.pos.multimethod_s(Vec3)
def _(self):
    return self

@operators.pos.multimethod_s(Quat)
def _(self):
    return self

@operators.mul.multimethod_s(Quat, Quat)
def _(self, other):
    ax, ay, az, aw = self.x, self.y, self.z, self.w
    bx, by, bz, bw = other.x, other.y, other.z, other.w
    return Quat(
        ax * bw + aw * bx + ay * bz - az * by,
        ay * bw + aw * by + az * bx - ax * bz,
        az * bw + aw * bz + ax * by - ay * bx,
        aw * bw - ax * bx - ay * by - az * bz)

# This is probably properly treated as a transform instead?
@operators.mul.multimethod_s(Quat, Vec3)
def _(self, other):
    qx, qy, qz, qw = self.x, self.y, self.z, self.w
    x, y, z = other.x, other.y, other.z
    ix = qw * x + qy * z - qz * y
    iy = qw * y + qz * x - qx * z
    iz = qw * z + qx * y - qy * x
    iw = -qx * x - qy * y - qz * z
    return Vec3(
        ix * qw + iw * -qx + iy * -qz - iz * -qy,
        iy * qw + iw * -qy + iz * -qx - ix * -qz,
        iz * qw + iw * -qz + ix * -qy - iy * -qx)

@Builtin
@signature(Vec3, Float)
def axisangle(v, angle):
    angle = to_float(angle)
    x, y, z = v.x, v.y, v.z
    s = sin(angle * 0.5)
    return Quat(s*x, s*y, s*z, cos(angle * 0.5))

class Mat4(Object):
    __slots__ = ['values']
    _immutable_fields_ = ['values[*]']
    def __init__(self, values):
        self.values = list(values)

    def getattr(self, name):
        if name == u"length":
            return Integer(16)
        return Object.getattr(self, name)

    def iter(self):
        seq = []
        for x in self.values:
            seq.append(Float(x))
        return List(seq).iter()

    #def __repr__(self):
    #    return "mat4({})".format(self.values)

@Mat4.instantiator
def _(argv):
    if len(argv) > 16:
        raise OldError(u"Too many arguments to mat4")
    mat = [1.0, 0.0, 0.0, 0.0,
           0.0, 1.0, 0.0, 0.0,
           0.0, 0.0, 1.0, 0.0,
           0.0, 0.0, 0.0, 1.0]
    for i, arg in enumerate(argv):
        mat[i] = to_float(arg)
    return Mat4(mat)

@Mat4.builtin_method
@signature(Mat4)
def transpose(self):
    a = self.values
    return Mat4([a[0], a[4], a[8], a[12], a[1], a[5], a[9], a[13], a[2], a[6], a[10], a[14], a[3], a[7], a[11], a[15]])

@Mat4.builtin_method
@signature(Mat4)
def invert(self):
    a = self.values
    a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3];
    a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7];
    a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11];
    a30 = a[12]; a31 = a[13]; a32 = a[14]; a33 = a[15];

    b00 = a00 * a11 - a01 * a10
    b01 = a00 * a12 - a02 * a10
    b02 = a00 * a13 - a03 * a10
    b03 = a01 * a12 - a02 * a11
    b04 = a01 * a13 - a03 * a11
    b05 = a02 * a13 - a03 * a12
    b06 = a20 * a31 - a21 * a30
    b07 = a20 * a32 - a22 * a30
    b08 = a20 * a33 - a23 * a30
    b09 = a21 * a32 - a22 * a31
    b10 = a21 * a33 - a23 * a31
    b11 = a22 * a33 - a23 * a32
    det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06
    if det == 0.0:
        return None
    det = 1.0 / det

    return Mat4([
        (a11 * b11 - a12 * b10 + a13 * b09) * det,
        (a02 * b10 - a01 * b11 - a03 * b09) * det,
        (a31 * b05 - a32 * b04 + a33 * b03) * det,
        (a22 * b04 - a21 * b05 - a23 * b03) * det,
        (a12 * b08 - a10 * b11 - a13 * b07) * det,
        (a00 * b11 - a02 * b08 + a03 * b07) * det,
        (a32 * b02 - a30 * b05 - a33 * b01) * det,
        (a20 * b05 - a22 * b02 + a23 * b01) * det,
        (a10 * b10 - a11 * b08 + a13 * b06) * det,
        (a01 * b08 - a00 * b10 - a03 * b06) * det,
        (a30 * b04 - a31 * b02 + a33 * b00) * det,
        (a21 * b02 - a20 * b04 - a23 * b00) * det,
        (a11 * b07 - a10 * b09 - a12 * b06) * det,
        (a00 * b09 - a01 * b07 + a02 * b06) * det,
        (a31 * b01 - a30 * b03 - a32 * b00) * det,
        (a20 * b03 - a21 * b01 + a22 * b00) * det])

@Mat4.builtin_method
@signature(Mat4)
def adjoint(self):
    a = self.values
    a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3];
    a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7];
    a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11];
    a30 = a[12]; a31 = a[13]; a32 = a[14]; a33 = a[15];
    return Mat4([
         (a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22)),
        -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22)),
         (a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12)),
        -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12)),
        -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22)),
         (a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22)),
        -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12)),
         (a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12)),
         (a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21)),
        -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21)),
         (a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11)),
        -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11)),
        -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21)),
         (a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21)),
        -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11)),
         (a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11))])

@Mat4.builtin_method
@signature(Mat4)
def determinant(self):
    a = self.values
    a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3];
    a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7];
    a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11];
    a30 = a[12]; a31 = a[13]; a32 = a[14]; a33 = a[15];
    b00 = a00 * a11 - a01 * a10
    b01 = a00 * a12 - a02 * a10
    b02 = a00 * a13 - a03 * a10
    b03 = a01 * a12 - a02 * a11
    b04 = a01 * a13 - a03 * a11
    b05 = a02 * a13 - a03 * a12
    b06 = a20 * a31 - a21 * a30
    b07 = a20 * a32 - a22 * a30
    b08 = a20 * a33 - a23 * a30
    b09 = a21 * a32 - a22 * a31
    b10 = a21 * a33 - a23 * a31
    b11 = a22 * a33 - a23 * a32
    return Float(b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06)

@Mat4.builtin_method
@signature(Mat4, Vec3)
def rotate_vec3(self, v):
    a = self.values
    x, y, z = v.x, v.y, v.z
    return Vec3(
        a[0]*x + a[4]*y + a[8]*z,
        a[1]*x + a[5]*y + a[9]*z,
        a[2]*x + a[6]*y + a[10]*z)

@operators.mul.multimethod_s(Mat4, Vec3)
def _(self, other):
    a = self.values
    a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3];
    a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7];
    a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11];
    a30 = a[12]; a31 = a[13]; a32 = a[14]; a33 = a[15];
    x, y, z = other.x, other.y, other.z
    return Vec3(
        a00*x + a10*y + a20*z + a30,
        a01*x + a11*y + a21*z + a31,
        a02*x + a12*y + a22*z + a32)

@operators.mul.multimethod_s(Mat4, Mat4)
def _(self, other):
    a = self.values
    a00 = a[0]; a01 = a[1]; a02 = a[2]; a03 = a[3];
    a10 = a[4]; a11 = a[5]; a12 = a[6]; a13 = a[7];
    a20 = a[8]; a21 = a[9]; a22 = a[10]; a23 = a[11];
    a30 = a[12]; a31 = a[13]; a32 = a[14]; a33 = a[15];
    b = other.values
    out = [0.0] * 16
    b0  = b[0]; b1 = b[1]; b2 = b[2]; b3 = b[3];
    out[0] = b0*a00 + b1*a10 + b2*a20 + b3*a30
    out[1] = b0*a01 + b1*a11 + b2*a21 + b3*a31
    out[2] = b0*a02 + b1*a12 + b2*a22 + b3*a32
    out[3] = b0*a03 + b1*a13 + b2*a23 + b3*a33

    b0 = b[4]; b1 = b[5]; b2 = b[6]; b3 = b[7];
    out[4] = b0*a00 + b1*a10 + b2*a20 + b3*a30
    out[5] = b0*a01 + b1*a11 + b2*a21 + b3*a31
    out[6] = b0*a02 + b1*a12 + b2*a22 + b3*a32
    out[7] = b0*a03 + b1*a13 + b2*a23 + b3*a33

    b0 = b[8]; b1 = b[9]; b2 = b[10]; b3 = b[11];
    out[8] = b0*a00 + b1*a10 + b2*a20 + b3*a30
    out[9] = b0*a01 + b1*a11 + b2*a21 + b3*a31
    out[10] = b0*a02 + b1*a12 + b2*a22 + b3*a32
    out[11] = b0*a03 + b1*a13 + b2*a23 + b3*a33

    b0 = b[12]; b1 = b[13]; b2 = b[14]; b3 = b[15];
    out[12] = b0*a00 + b1*a10 + b2*a20 + b3*a30
    out[13] = b0*a01 + b1*a11 + b2*a21 + b3*a31
    out[14] = b0*a02 + b1*a12 + b2*a22 + b3*a32
    out[15] = b0*a03 + b1*a13 + b2*a23 + b3*a33
    return Mat4(out)

@Mat4.builtin_method
@signature(Mat4, Vec3)
def translate(self, v):
    x, y, z = v.x, v.y, v.z
    a = self.values
    return Mat4(a[0:12] + [
        a[0] * x + a[4] * y + a[8] * z + a[12],
        a[1] * x + a[5] * y + a[9] * z + a[13],
        a[2] * x + a[6] * y + a[10] * z + a[14],
        a[3] * x + a[7] * y + a[11] * z + a[15]])

@Mat4.builtin_method
@signature(Mat4, Vec3)
def scale(self, v):
    x, y, z = v.x, v.y, v.z
    a = self.values
    return Mat4([a[0]*x, a[1]*x, a[2]*x, a[3]*x, a[4]*y, a[5]*y, a[6]*y, a[7]*y, a[8]*z, a[9]*z, a[10]*z, a[11]*z, a[12], a[13], a[14], a[15]])

@operators.clamp.multimethod_s(Float, Float, Float)
def clamp(x, low, high):
    return Float(min(max(x.number, low.number), high.number))

@operators.clamp.multimethod_s(Integer, Integer, Integer)
def clamp(x, low, high):
    return Integer(min(max(x.value, low.value), high.value))

# This may move into stdlib module eventually, possibly.
random = Random()
masklower = r_ulonglong(0xffffffff)

# This code might break again if r_ulonglong is treated as 32-bit int.
def init_random():
    n = r_ulonglong(time.time())
    key = []
    while n > 0:
        key.append(r_uint(n & masklower))
        n >>= 32
    if len(key) == 0:
        key.append(r_uint(0))
    random.init_by_array(key)

@abs_.multimethod_s(Float)
def abs_float(f):
    return Float(-f.number) if f.number < 0.0 else f

@abs_.multimethod_s(Integer)
def abs_int(i):
    return Integer(-i.value) if i.value < 0 else i

@Builtin
@signature()
def random_():
    return Float(random.random())

@Builtin
@signature()
def random_circle():
    r = random.random() * 2.0 * pi
    return Vec3(cos(r), sin(r), 0.0)

@Builtin
@signature()
def random_sphere():
    r = random.random() * 2.0 * pi
    z = (random.random() * 2.0) - 1.0
    s = sqrt(1.0 - z*z)
    return Vec3(cos(r) * s, sin(r) * s, z)

# These may also belong somewhere else, but they start here.
@Builtin
@signature(Float)
def sin_(f):
    return Float(sin(f.number))

@Builtin
@signature(Float)
def cos_(f):
    return Float(cos(f.number))

@Builtin
@signature(Float)
def tan_(f):
    return Float(tan(f.number))

@Builtin
@signature(Float)
def asin_(f):
    return Float(asin(f.number))

@Builtin
@signature(Float)
def acos_(f):
    return Float(acos(f.number))

@Builtin
@signature(Float)
def atan_(x):
    return Float(atan(x.number))

@Builtin
@signature(Float, Float)
def atan2_(y, x):
    return Float(atan2(y.number, x.number))

@Builtin
@signature(Float)
def sqrt_(f):
    return Float(sqrt(f.number))

@pow_.multimethod_s(Float, Float)
def pow_float(a, b):
    try:
        return Float(powf(a.number, b.number))
    except OverflowError as ovf:
        raise unwind(LError(u"math range error"))
    except ValueError as val:
        raise unwind(LError(u"math domain error"))

@pow_.multimethod_s(Integer, Integer)
def pow_int(a, b):
    try:
        return Integer(powi(a.value, b.value))
    except OverflowError as ovf:
        raise unwind(LError(u"math range error"))
    except ValueError as val:
        raise unwind(LError(u"math domain error"))

def powi(iv, iw):
    temp = iv
    ix = 1
    while iw > 0:
        if iw & 1:
            ix = ix * temp
        iw >>= 1   # Shift exponent down by 1 bit
        if iw == 0:
            break
        temp = temp * temp # Square the value of temp
    return ix

@Builtin
@signature(Float)
def exp_(a):
    return Float(exp(a.number))

@Builtin
@signature(Float, Float)
def log_(a, b):
    return Float(log(a.number) / log(b.number))

@Builtin
@signature(Float)
def ln(a):
    return Float(log(a.number))

@Builtin
@signature(Float)
def sign(f):
    if f.number < 0.0:
        return Float(-1.0)
    elif f.number > 0.0:
        return Float(+1.0)
    else:
        return Float(0.0)

@Builtin
@signature(Object, Object, Object, Object)
def projection_matrix(fovy, aspect, znear, zfar):
    fovy = to_float(fovy)
    aspect = to_float(aspect)
    znear = to_float(znear)
    zfar = to_float(zfar)
    f = 1/tan(fovy/2.0)
    zd = znear-zfar
    return Mat4([
        f/aspect, 0.0,  0.0,                 0.0,
        0.0,        f,  0.0,                 0.0,
        0.0,      0.0,  (zfar+znear) / zd,   -1.0,
        0.0,      0.0,  (2*zfar*znear) / zd, 0.0
    ])

@Builtin
@signature(Float)
def frexp_(a):
    mantissa, exponent = frexp(a.number)
    return List([Float(mantissa), Integer(rffi.r_long(exponent))])

@Builtin
@signature(Float, Integer)
def ldexp_(mantissa, exponent):
    return Float(ldexp(mantissa.number, int(exponent.value)))

# This may not be a good approach to incrementing a float an epsilon ahead.
@Builtin
@signature(Float)
def next_increment(a):
    mantissa, exponent = frexp(a.number)
    if mantissa == 0.0:
        return Float(DBL_MIN)
    mantissa += DBL_EPSILON / 2.0
    return Float(ldexp(mantissa, exponent))

by_symbol = {
    u"vec3": Vec3.interface,
    u"quat": Quat.interface,
    u"mat4": Mat4.interface,
    u"left":     Vec3(-1.0, 0.0, 0.0),
    u"right":    Vec3(+1.0, 0.0, 0.0),
    u"up":       Vec3( 0.0,+1.0, 0.0),
    u"down":     Vec3( 0.0,-1.0, 0.0),
    u"forward":  Vec3( 0.0, 0.0,+1.0),
    u"backward": Vec3( 0.0, 0.0,-1.0),
    u"axisangle": axisangle,
    u"random":        random_,
    u"random_circle": random_circle,
    u"random_sphere": random_sphere,
    u"length":    length,
    u"dot":       dot,
    u"cross":     cross,
    u"normalize": normalize,
    u"sin":       sin_,
    u"cos":       cos_,
    u"tan":       tan_,
    u"sqrt":      sqrt_,
    u"pi":        Float(pi),
    u"tau":       Float(pi*2),
    u"projection_matrix": projection_matrix,
    u"ldexp": ldexp_,
    u"frexp": frexp_,
    u"next_increment": next_increment,
    u"abs":       abs_,
    u"sign":      sign,
    u"acos":      acos_,
    u"asin":      asin_,
    u"atan":      atan_,
    u"atan2":     atan2_,
    u"pow":       pow_,
    u"exp":       exp_,
    u"log":       log_,
    u"ln":        ln,
    u"e":         Float(e),
    u'inf': Float(INFINITY),
    u'nan': Float(NAN),
    u'dbl_min': Float(DBL_MIN),
    u'dbl_max': Float(DBL_MAX),
    u'dbl_epsilon': Float(DBL_EPSILON),
}