simpok 0.1.0__py3-none-any.whl

simpok/__init__.py

@@ -0,0 +1,6 @@
+from .device import Device, get_device
+from ._result import Result
+from .tdgl import TDGL
+from .chc import CHC
+
+__all__ = ["Device", "get_device", "TDGL", "CHC", "Result"]

simpok/_core_mojo/__init__.mojo

@@ -0,0 +1,3 @@
+from ._utils import get_device
+from ._tdgl import run_tdgl
+from ._chc import run_chc

simpok/_core_mojo/_chc.mojo

@@ -0,0 +1,336 @@
+from std.math import ceildiv, sqrt
+from std.memory import unsafe_memcpy
+from std.memory.alloc import alloc, Layout
+from std.sys import has_accelerator, size_of
+from std.sys.info import has_apple_gpu_accelerator
+from std.gpu import global_idx
+from max.gpu.host import DeviceContext
+from layout import TileTensor, TensorLayout, row_major
+
+from ._utils import gaussian, TPB, DEVICE_ACCEL, DEVICE_CPU
+
+
+def _mu[dt: DType](
+    c: Scalar[dt],
+    xp: Scalar[dt],
+    xm: Scalar[dt],
+    yp: Scalar[dt],
+    ym: Scalar[dt],
+    inv_dx2: Scalar[dt],
+) -> Scalar[dt]:
+    return -c + c * c * c - (xp + xm + yp + ym - 4.0 * c) * inv_dx2
+
+
+def _update[dt: DType](
+    c: Scalar[dt],
+    xp: Scalar[dt],
+    xm: Scalar[dt],
+    yp: Scalar[dt],
+    ym: Scalar[dt],
+    xpp: Scalar[dt],
+    xmm: Scalar[dt],
+    ypp: Scalar[dt],
+    ymm: Scalar[dt],
+    pp: Scalar[dt],
+    pm: Scalar[dt],
+    mp: Scalar[dt],
+    mm: Scalar[dt],
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+) -> Scalar[dt]:
+    var mc = _mu[dt](c, xp, xm, yp, ym, inv_dx2)
+    var mxp = _mu[dt](xp, xpp, c, pp, pm, inv_dx2)
+    var mxm = _mu[dt](xm, c, xmm, mp, mm, inv_dx2)
+    var myp = _mu[dt](yp, pp, mp, ypp, c, inv_dx2)
+    var mym = _mu[dt](ym, pm, mm, c, ymm, inv_dx2)
+    return c + step_dt * (mxp + mxm + myp + mym - 4.0 * mc) * inv_dx2
+
+
+def _divnoise[dt: DType](
+    n: Int, i: Int, j: Int, im: Int, jm: Int, seed: UInt64, step: UInt64
+) -> Scalar[dt]:
+    var here = UInt64(2 * (i * n + j))
+    return (
+        gaussian[dt](seed, step, here)
+        - gaussian[dt](seed, step, UInt64(2 * (i * n + jm)))
+        + gaussian[dt](seed, step, here + 1)
+        - gaussian[dt](seed, step, UInt64(2 * (im * n + j) + 1))
+    )
+
+
+def _step_kernel[dt: DType, LT: TensorLayout](
+    psi: TileTensor[dt, LT, MutAnyOrigin],
+    nxt: TileTensor[dt, LT, MutAnyOrigin],
+    n: Int32,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step: UInt64,
+):
+    comptime assert psi.flat_rank == 2, "field must be 2d"
+    comptime assert nxt.flat_rank == 2, "field must be 2d"
+    var nn = Int(n)
+    var j = Int(global_idx.x)
+    var i = Int(global_idx.y)
+    if i >= nn or j >= nn:
+        return
+
+    var ip = i + 1 if i + 1 < nn else i + 1 - nn
+    var im = i - 1 if i >= 1 else i - 1 + nn
+    var jp = j + 1 if j + 1 < nn else j + 1 - nn
+    var jm = j - 1 if j >= 1 else j - 1 + nn
+    var ipp = i + 2 if i + 2 < nn else i + 2 - nn
+    var imm = i - 2 if i >= 2 else i - 2 + nn
+    var jpp = j + 2 if j + 2 < nn else j + 2 - nn
+    var jmm = j - 2 if j >= 2 else j - 2 + nn
+
+    var v = _update[dt](
+        rebind[Scalar[dt]](psi[i, j]),
+        rebind[Scalar[dt]](psi[ip, j]),
+        rebind[Scalar[dt]](psi[im, j]),
+        rebind[Scalar[dt]](psi[i, jp]),
+        rebind[Scalar[dt]](psi[i, jm]),
+        rebind[Scalar[dt]](psi[ipp, j]),
+        rebind[Scalar[dt]](psi[imm, j]),
+        rebind[Scalar[dt]](psi[i, jpp]),
+        rebind[Scalar[dt]](psi[i, jmm]),
+        rebind[Scalar[dt]](psi[ip, jp]),
+        rebind[Scalar[dt]](psi[ip, jm]),
+        rebind[Scalar[dt]](psi[im, jp]),
+        rebind[Scalar[dt]](psi[im, jm]),
+        step_dt,
+        inv_dx2,
+    )
+    if noise_amp != 0.0:
+        v += noise_amp * _divnoise[dt](nn, i, j, im, jm, seed, step)
+    nxt[i, j] = rebind[nxt.ElementType](v)
+
+
+def _step_cpu[dt: DType](
+    psi: Pointer[Scalar[dt], MutAnyOrigin],
+    nxt: Pointer[Scalar[dt], MutAnyOrigin],
+    n: Int,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step: UInt64,
+):
+    for i in range(n):
+        var ip = i + 1 if i + 1 < n else i + 1 - n
+        var im = i - 1 if i >= 1 else i - 1 + n
+        var ipp = i + 2 if i + 2 < n else i + 2 - n
+        var imm = i - 2 if i >= 2 else i - 2 + n
+        for j in range(n):
+            var jp = j + 1 if j + 1 < n else j + 1 - n
+            var jm = j - 1 if j >= 1 else j - 1 + n
+            var jpp = j + 2 if j + 2 < n else j + 2 - n
+            var jmm = j - 2 if j >= 2 else j - 2 + n
+            var v = _update[dt](
+                psi[unsafe_offset=i * n + j],
+                psi[unsafe_offset=ip * n + j],
+                psi[unsafe_offset=im * n + j],
+                psi[unsafe_offset=i * n + jp],
+                psi[unsafe_offset=i * n + jm],
+                psi[unsafe_offset=ipp * n + j],
+                psi[unsafe_offset=imm * n + j],
+                psi[unsafe_offset=i * n + jpp],
+                psi[unsafe_offset=i * n + jmm],
+                psi[unsafe_offset=ip * n + jp],
+                psi[unsafe_offset=ip * n + jm],
+                psi[unsafe_offset=im * n + jp],
+                psi[unsafe_offset=im * n + jm],
+                step_dt,
+                inv_dx2,
+            )
+            if noise_amp != 0.0:
+                v += noise_amp * _divnoise[dt](n, i, j, im, jm, seed, step)
+            nxt[unsafe_offset=i * n + j] = v
+
+
+def _run_cpu[dt: DType](
+    field: Pointer[Scalar[dt], MutAnyOrigin],
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step0: Int,
+) raises -> String:
+    comptime esize = size_of[Scalar[dt]]()
+    var size = n * n
+    var owned_a = alloc(Layout[Scalar[dt]](count=size)).into_managed()
+    var owned_b = alloc(Layout[Scalar[dt]](count=size)).into_managed()
+    var a = Pointer[Scalar[dt], MutAnyOrigin](
+        unsafe_from_address=Int(owned_a.unsafe_ptr())
+    )
+    var b = Pointer[Scalar[dt], MutAnyOrigin](
+        unsafe_from_address=Int(owned_b.unsafe_ptr())
+    )
+    unsafe_memcpy(dest=a, src=field, count=size)
+
+    var k = 0
+    for s in range(1, nsteps + 1):
+        _step_cpu[dt](
+            a, b, n, step_dt, inv_dx2, noise_amp, seed, UInt64(step0 + s - 1),
+        )
+        swap(a, b)
+        if s % nevery == 0:
+            var dst = Pointer[Scalar[dt], MutAnyOrigin](
+                unsafe_from_address=snaps_addr + k * size * esize
+            )
+            unsafe_memcpy(dest=dst, src=a, count=size)
+            k += 1
+
+    unsafe_memcpy(dest=field, src=a, count=size)
+    _ = owned_a^
+    _ = owned_b^
+    return String("cpu")
+
+
+def _run_accel[dt: DType](
+    field: Pointer[Scalar[dt], MutAnyOrigin],
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step0: Int,
+) raises -> String:
+    comptime esize = size_of[Scalar[dt]]()
+    var size = n * n
+    var ctx = DeviceContext()
+    var a = ctx.enqueue_create_buffer[dt](size)
+    var b = ctx.enqueue_create_buffer[dt](size)
+    ctx.enqueue_copy(dst_buf=a, src_ptr=field)
+
+    var layout = row_major(n, n)
+    comptime kern = _step_kernel[dt, type_of(layout)]
+    var grid = (ceildiv(n, TPB), ceildiv(n, TPB))
+
+    var k = 0
+    for s in range(1, nsteps + 1):
+        ctx.enqueue_function[kern](
+            TileTensor(a, layout),
+            TileTensor(b, layout),
+            Int32(n),
+            step_dt,
+            inv_dx2,
+            noise_amp,
+            seed,
+            UInt64(step0 + s - 1),
+            grid_dim=grid,
+            block_dim=(TPB, TPB),
+        )
+        swap(a, b)
+        if s % nevery == 0:
+            var dst = Pointer[Scalar[dt], MutAnyOrigin](
+                unsafe_from_address=snaps_addr + k * size * esize
+            )
+            ctx.enqueue_copy(dst_ptr=dst, src_buf=a)
+            k += 1
+
+    ctx.enqueue_copy(dst_ptr=field, src_buf=a)
+    ctx.synchronize()
+    return String("accelerator")
+
+
+def _dispatch[dt: DType](
+    field_addr: Int,
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Float64,
+    dx: Float64,
+    eps: Float64,
+    seed: Int,
+    step0: Int,
+    device: Int,
+) raises -> String:
+    var field = Pointer[Scalar[dt], MutAnyOrigin](
+        unsafe_from_address=field_addr
+    )
+    var inv_dx2 = 1.0 / (dx * dx)
+    var amp = sqrt(2.0 * eps * step_dt) * inv_dx2 if eps > 0.0 else 0.0
+    var sdt = Scalar[dt](step_dt)
+    var sidx = Scalar[dt](inv_dx2)
+    var samp = Scalar[dt](amp)
+    var useed = UInt64(seed)
+
+    comptime no_f64_on_accel = (
+        has_apple_gpu_accelerator() and dt == DType.float64
+    )
+
+    comptime if not has_accelerator():
+        if device == DEVICE_ACCEL:
+            raise Error(
+                "accelerator requested but this build has no supported"
+                " accelerator"
+            )
+        return _run_cpu[dt](
+            field, snaps_addr, n, nsteps, nevery, sdt, sidx, samp, useed, step0,
+        )
+    else:
+        comptime if no_f64_on_accel:
+            if device == DEVICE_ACCEL:
+                raise Error(
+                    "accelerator requested but it has no float64"
+                    " support; use dtype=float32"
+                )
+            return _run_cpu[dt](
+                field, snaps_addr, n, nsteps, nevery, sdt, sidx, samp, useed,
+                step0,
+            )
+        else:
+            if device == DEVICE_CPU:
+                return _run_cpu[dt](
+                    field, snaps_addr, n, nsteps, nevery, sdt, sidx, samp,
+                    useed, step0,
+                )
+            if DeviceContext.number_of_devices() == 0:
+                if device == DEVICE_ACCEL:
+                    raise Error(
+                        "accelerator requested but none was detected"
+                        " at runtime"
+                    )
+                return _run_cpu[dt](
+                    field, snaps_addr, n, nsteps, nevery, sdt, sidx, samp,
+                    useed, step0,
+                )
+            return _run_accel[dt](
+                field, snaps_addr, n, nsteps, nevery, sdt, sidx, samp, useed,
+                step0,
+            )
+
+
+def run_chc(
+    field_addr: Int,
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Float64,
+    dx: Float64,
+    eps: Float64,
+    seed: Int,
+    step0: Int,
+    single: Bool,
+    device: Int,
+) raises -> String:
+    if single:
+        return _dispatch[DType.float32](
+            field_addr, snaps_addr, n, nsteps, nevery, step_dt, dx, eps, seed,
+            step0, device,
+        )
+    return _dispatch[DType.float64](
+        field_addr, snaps_addr, n, nsteps, nevery, step_dt, dx, eps, seed,
+        step0, device,
+    )

simpok/_core_mojo/_tdgl.mojo

@@ -0,0 +1,290 @@
+from std.math import ceildiv, sqrt
+from std.memory import unsafe_memcpy
+from std.memory.alloc import alloc, Layout
+from std.sys import has_accelerator, size_of
+from std.sys.info import has_apple_gpu_accelerator
+from std.gpu import global_idx
+from max.gpu.host import DeviceContext
+from layout import TileTensor, TensorLayout, row_major
+
+from ._utils import gaussian, TPB, DEVICE_ACCEL, DEVICE_CPU
+
+
+def _update[dt: DType](
+    c: Scalar[dt],
+    up: Scalar[dt],
+    dn: Scalar[dt],
+    lf: Scalar[dt],
+    rt: Scalar[dt],
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    h: Scalar[dt],
+) -> Scalar[dt]:
+    var lap = (up + dn + lf + rt - 4.0 * c) * inv_dx2
+    return c + step_dt * (c - c * c * c + h + lap)
+
+
+def _step_kernel[dt: DType, LT: TensorLayout](
+    psi: TileTensor[dt, LT, MutAnyOrigin],
+    nxt: TileTensor[dt, LT, MutAnyOrigin],
+    n: Int32,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    h: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step: UInt64,
+):
+    comptime assert psi.flat_rank == 2, "field must be 2d"
+    comptime assert nxt.flat_rank == 2, "field must be 2d"
+    var nn = Int(n)
+    var j = global_idx.x
+    var i = global_idx.y
+    if i >= nn or j >= nn:
+        return
+
+    var ip = i + 1 if i + 1 < nn else 0
+    var im = i - 1 if i > 0 else nn - 1
+    var jp = j + 1 if j + 1 < nn else 0
+    var jm = j - 1 if j > 0 else nn - 1
+
+    var v = _update[dt](
+        rebind[Scalar[dt]](psi[i, j]),
+        rebind[Scalar[dt]](psi[ip, j]),
+        rebind[Scalar[dt]](psi[im, j]),
+        rebind[Scalar[dt]](psi[i, jp]),
+        rebind[Scalar[dt]](psi[i, jm]),
+        step_dt,
+        inv_dx2,
+        h,
+    )
+    if noise_amp != 0.0:
+        v += noise_amp * gaussian[dt](seed, step, UInt64(i * nn + j))
+    nxt[i, j] = rebind[nxt.ElementType](v)
+
+
+def _step_cpu[dt: DType](
+    psi: Pointer[Scalar[dt], MutAnyOrigin],
+    nxt: Pointer[Scalar[dt], MutAnyOrigin],
+    n: Int,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    h: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step: UInt64,
+):
+    for i in range(n):
+        var ip = i + 1 if i + 1 < n else 0
+        var im = i - 1 if i > 0 else n - 1
+        for j in range(n):
+            var jp = j + 1 if j + 1 < n else 0
+            var jm = j - 1 if j > 0 else n - 1
+            var v = _update[dt](
+                psi[unsafe_offset=i * n + j],
+                psi[unsafe_offset=ip * n + j],
+                psi[unsafe_offset=im * n + j],
+                psi[unsafe_offset=i * n + jp],
+                psi[unsafe_offset=i * n + jm],
+                step_dt,
+                inv_dx2,
+                h,
+            )
+            if noise_amp != 0.0:
+                v += noise_amp * gaussian[dt](seed, step, UInt64(i * n + j))
+            nxt[unsafe_offset=i * n + j] = v
+
+
+def _run_cpu[dt: DType](
+    field: Pointer[Scalar[dt], MutAnyOrigin],
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    h: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step0: Int,
+) raises -> String:
+    comptime esize = size_of[Scalar[dt]]()
+    var size = n * n
+    var owned_a = alloc(Layout[Scalar[dt]](count=size)).into_managed()
+    var owned_b = alloc(Layout[Scalar[dt]](count=size)).into_managed()
+    var a = Pointer[Scalar[dt], MutAnyOrigin](
+        unsafe_from_address=Int(owned_a.unsafe_ptr())
+    )
+    var b = Pointer[Scalar[dt], MutAnyOrigin](
+        unsafe_from_address=Int(owned_b.unsafe_ptr())
+    )
+    unsafe_memcpy(dest=a, src=field, count=size)
+
+    var k = 0
+    for s in range(1, nsteps + 1):
+        _step_cpu[dt](
+            a, b, n, step_dt, inv_dx2, h, noise_amp, seed,
+            UInt64(step0 + s - 1),
+        )
+        swap(a, b)
+        if s % nevery == 0:
+            var dst = Pointer[Scalar[dt], MutAnyOrigin](
+                unsafe_from_address=snaps_addr + k * size * esize
+            )
+            unsafe_memcpy(dest=dst, src=a, count=size)
+            k += 1
+
+    unsafe_memcpy(dest=field, src=a, count=size)
+    _ = owned_a^
+    _ = owned_b^
+    return String("cpu")
+
+
+def _run_accel[dt: DType](
+    field: Pointer[Scalar[dt], MutAnyOrigin],
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Scalar[dt],
+    inv_dx2: Scalar[dt],
+    h: Scalar[dt],
+    noise_amp: Scalar[dt],
+    seed: UInt64,
+    step0: Int,
+) raises -> String:
+    comptime esize = size_of[Scalar[dt]]()
+    var size = n * n
+    var ctx = DeviceContext()
+    var a = ctx.enqueue_create_buffer[dt](size)
+    var b = ctx.enqueue_create_buffer[dt](size)
+    ctx.enqueue_copy(dst_buf=a, src_ptr=field)
+
+    var layout = row_major(n, n)
+    comptime kern = _step_kernel[dt, type_of(layout)]
+    var grid = (ceildiv(n, TPB), ceildiv(n, TPB))
+
+    var k = 0
+    for s in range(1, nsteps + 1):
+        ctx.enqueue_function[kern](
+            TileTensor(a, layout),
+            TileTensor(b, layout),
+            Int32(n),
+            step_dt,
+            inv_dx2,
+            h,
+            noise_amp,
+            seed,
+            UInt64(step0 + s - 1),
+            grid_dim=grid,
+            block_dim=(TPB, TPB),
+        )
+        swap(a, b)
+        if s % nevery == 0:
+            var dst = Pointer[Scalar[dt], MutAnyOrigin](
+                unsafe_from_address=snaps_addr + k * size * esize
+            )
+            ctx.enqueue_copy(dst_ptr=dst, src_buf=a)
+            k += 1
+
+    ctx.enqueue_copy(dst_ptr=field, src_buf=a)
+    ctx.synchronize()
+    return String("accelerator")
+
+
+def _dispatch[dt: DType](
+    field_addr: Int,
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Float64,
+    dx: Float64,
+    h: Float64,
+    eps: Float64,
+    seed: Int,
+    step0: Int,
+    device: Int,
+) raises -> String:
+    var field = Pointer[Scalar[dt], MutAnyOrigin](
+        unsafe_from_address=field_addr
+    )
+    var inv_dx2 = 1.0 / (dx * dx)
+    var amp = sqrt(2.0 * eps * step_dt * inv_dx2) if eps > 0.0 else 0.0
+    var sdt = Scalar[dt](step_dt)
+    var sidx = Scalar[dt](inv_dx2)
+    var sh = Scalar[dt](h)
+    var samp = Scalar[dt](amp)
+    var useed = UInt64(seed)
+
+    comptime no_f64_on_accel = (
+        has_apple_gpu_accelerator() and dt == DType.float64
+    )
+
+    comptime if not has_accelerator():
+        if device == DEVICE_ACCEL:
+            raise Error(
+                "accelerator requested but this build has no supported"
+                " accelerator"
+            )
+        return _run_cpu[dt](
+            field, snaps_addr, n, nsteps, nevery, sdt, sidx, sh,
+            samp, useed, step0,
+        )
+    else:
+        comptime if no_f64_on_accel:
+            if device == DEVICE_ACCEL:
+                raise Error(
+                    "accelerator requested but it has no float64"
+                    " support; use dtype=float32"
+                )
+            return _run_cpu[dt](
+                field, snaps_addr, n, nsteps, nevery, sdt, sidx, sh,
+                samp, useed, step0,
+            )
+        else:
+            if device == DEVICE_CPU:
+                return _run_cpu[dt](
+                    field, snaps_addr, n, nsteps, nevery, sdt, sidx, sh,
+                    samp, useed, step0,
+                )
+            if DeviceContext.number_of_devices() == 0:
+                if device == DEVICE_ACCEL:
+                    raise Error(
+                        "accelerator requested but none was detected"
+                        " at runtime"
+                    )
+                return _run_cpu[dt](
+                    field, snaps_addr, n, nsteps, nevery, sdt, sidx, sh,
+                    samp, useed, step0,
+                )
+            return _run_accel[dt](
+                field, snaps_addr, n, nsteps, nevery, sdt, sidx, sh,
+                samp, useed, step0,
+            )
+
+
+def run_tdgl(
+    field_addr: Int,
+    snaps_addr: Int,
+    n: Int,
+    nsteps: Int,
+    nevery: Int,
+    step_dt: Float64,
+    dx: Float64,
+    h: Float64,
+    eps: Float64,
+    seed: Int,
+    step0: Int,
+    single: Bool,
+    device: Int,
+) raises -> String:
+    if single:
+        return _dispatch[DType.float32](
+            field_addr, snaps_addr, n, nsteps, nevery, step_dt, dx, h,
+            eps, seed, step0, device,
+        )
+    return _dispatch[DType.float64](
+        field_addr, snaps_addr, n, nsteps, nevery, step_dt, dx, h,
+        eps, seed, step0, device,
+    )

simpok/_core_mojo/_utils.mojo

@@ -0,0 +1,49 @@
+from std.math import sqrt, log, cos
+from std.sys import has_accelerator
+from max.gpu.host import DeviceContext
+
+comptime DEVICE_AUTO = 0
+comptime DEVICE_ACCEL = 1
+comptime DEVICE_CPU = 2
+
+comptime TPB = 16
+comptime GOLDEN = 0x9E3779B97F4A7C15
+comptime TWO_PI = 6.283185307179586
+
+
+def get_device() -> Tuple[Bool, String, String]:
+    comptime if not has_accelerator():
+        return (
+            False, String(""), String("no supported accelerator at build time")
+        )
+    else:
+        try:
+            if DeviceContext.number_of_devices() == 0:
+                return (False, String(""), String("no accelerator detected"))
+            var ctx = DeviceContext()
+            return (True, ctx.name(), String(""))
+        except e:
+            return (False, String(""), String(e))
+
+
+def mix(x: UInt64) -> UInt64:
+    var z = x + GOLDEN
+    z = (z ^ (z >> 30)) * 0xBF58476D1CE4E5B9
+    z = (z ^ (z >> 27)) * 0x94D049BB133111EB
+    return z ^ (z >> 31)
+
+
+def gaussian[dt: DType](
+    seed: UInt64, step: UInt64, site: UInt64
+) -> Scalar[dt]:
+    comptime assert dt.is_floating_point(), "dt must be a float type"
+    comptime shift: UInt64 = 40 if dt == DType.float32 else 11
+    comptime scale = (
+        1.0 / 16777216.0 if dt == DType.float32 else 1.1102230246251565e-16
+    )
+    var h1 = mix(seed ^ mix(step * GOLDEN ^ site))
+    var h2 = mix(h1)
+    var u1 = (Scalar[dt](h1 >> shift) + 1.0) * Scalar[dt](scale)
+    var u2 = Scalar[dt](h2 >> shift) * Scalar[dt](scale)
+    var phase = cos(Float32(TWO_PI) * Float32(u2))
+    return sqrt(-2.0 * log(u1)) * Scalar[dt](phase)

simpok/_result.py

@@ -0,0 +1,55 @@
+from typing import NamedTuple
+
+import numpy as np
+
+_DEVICE_NAME = None
+_DEVICE_CODES = {"auto": 0, "accelerator": 1, "gpu": 1, "cpu": 2}
+
+
+class Result(NamedTuple):
+    snaps: np.ndarray
+    meta: dict
+
+
+def device_name():
+    global _DEVICE_NAME
+
+    if _DEVICE_NAME is None:
+        from .device import get_device
+
+        _DEVICE_NAME = get_device().name or "cpu"
+    return _DEVICE_NAME
+
+
+def device_code(device):
+    try:
+        return _DEVICE_CODES[device]
+    except (KeyError, TypeError):
+        raise ValueError(
+            f"device must be one of {sorted(_DEVICE_CODES)}, got {device!r}"
+        ) from None
+
+
+def make_meta(solver, *, n, dx, dt, dtype, seed, amplitude, steps, nevery,
+              step_start, step_end, backend, device, elapsed, **physics):
+    nsnap = steps // nevery
+    meta = {"solver": solver, "n": n, "dx": dx, "dt": dt}
+    meta.update(physics)
+    meta.update(
+        {
+            "dtype": np.dtype(dtype).name,
+            "seed": seed,
+            "amplitude": amplitude,
+            "steps": steps,
+            "nevery": nevery,
+            "nsnap": nsnap,
+            "step_start": step_start,
+            "step_end": step_end,
+            "times": (step_start + np.arange(1, nsnap + 1) * nevery) * dt,
+            "backend": backend,
+            "device": device_name(),
+            "device_request": device,
+            "elapsed": elapsed,
+        }
+    )
+    return meta

simpok/chc.py

@@ -0,0 +1,131 @@
+import time
+import numpy as np
+from ._result import Result, device_code, make_meta
+
+class CHC:
+    def __init__(self, n=256, dx=1.0, dt=0.01, eps=0.0,
+                 dtype=np.float64, device="auto"):
+        dtype = np.dtype(dtype)
+        self._device_code = device_code(device)
+        self.device = device
+        if dtype not in (np.dtype(np.float32), np.dtype(np.float64)):
+            raise ValueError(
+                f"dtype must be float32 or float64, got {dtype.name}"
+            )
+        if int(n) != n or n < 5:
+            raise ValueError(f"n must be an integer >= 5, got {n!r}")
+        if dx <= 0.0:
+            raise ValueError(f"dx must be positive, got {dx!r}")
+        if dt <= 0.0:
+            raise ValueError(f"dt must be positive, got {dt!r}")
+        if eps < 0.0:
+            raise ValueError(f"eps must be non-negative, got {eps!r}")
+
+        q = 8.0 / (dx * dx)
+        growth = q * q - q
+        if growth > 0.0:
+            limit = 2.0 / growth
+            if dt > limit:
+                raise ValueError(
+                    f"dt={dt} exceeds the explicit-Euler stability limit "
+                    f"{limit} for the 2-d 5-point biharmonic at dx={dx}"
+                )
+
+        self.n = int(n)
+        self.dx = float(dx)
+        self.dt = float(dt)
+        self.eps = float(eps)
+        self.dtype = dtype
+
+        self.psi = None
+        self.seed = 0
+        self.amplitude = 0.0
+        self.psi0 = 0.0
+        self.step = 0
+        self.backend = None
+
+    def ic(self, seed=0, amplitude=0.01, psi0=0.0):
+        if amplitude <= 0.0:
+            raise ValueError(f"amplitude must be positive, got {amplitude!r}")
+
+        rng = np.random.default_rng(seed)
+        self.psi = (
+            psi0 + rng.uniform(-amplitude, amplitude, size=(self.n, self.n))
+        ).astype(self.dtype)
+        self.seed = int(seed)
+        self.amplitude = float(amplitude)
+        self.psi0 = float(psi0)
+        self.step = 0
+        return self
+
+    @property
+    def t(self):
+        return self.step * self.dt
+
+    def run(self, steps, nevery):
+        if self.psi is None:
+            raise RuntimeError("call ic() before run()")
+        if np.shape(self.psi) != (self.n, self.n):
+            raise ValueError(
+                f"psi has shape {np.shape(self.psi)}, expected "
+                f"{(self.n, self.n)}"
+            )
+        if int(steps) != steps or steps < 1:
+            raise ValueError(f"steps must be a positive integer, got {steps!r}")
+        if int(nevery) != nevery or nevery < 1:
+            raise ValueError(
+                f"nevery must be a positive integer, got {nevery!r}"
+            )
+        if nevery > steps:
+            raise ValueError(f"nevery={nevery} exceeds steps={steps}")
+
+        steps = int(steps)
+        nevery = int(nevery)
+        nsnap = steps // nevery
+        step_start = self.step
+
+        import mojo.importer  # noqa: F401
+
+        from .mojo_module import _chc_run
+
+        field = np.ascontiguousarray(self.psi, dtype=self.dtype)
+        snaps = np.empty((nsnap, self.n, self.n), dtype=self.dtype)
+        params = (
+            self.n,
+            steps,
+            nevery,
+            self.dt,
+            self.dx,
+            self.eps,
+            self.seed,
+            self.step,
+            self.dtype == np.dtype(np.float32),
+            self._device_code,
+        )
+
+        t0 = time.perf_counter()
+        self.backend = _chc_run(field, snaps, params)
+        elapsed = time.perf_counter() - t0
+
+        self.psi = field
+        self.step += steps
+
+        meta = make_meta(
+            "chc",
+            n=self.n,
+            dx=self.dx,
+            dt=self.dt,
+            eps=self.eps,
+            psi0=self.psi0,
+            dtype=self.dtype,
+            seed=self.seed,
+            amplitude=self.amplitude,
+            steps=steps,
+            nevery=nevery,
+            step_start=step_start,
+            step_end=self.step,
+            backend=self.backend,
+            device=self.device,
+            elapsed=elapsed,
+        )
+        return Result(snaps, meta)

simpok/device.py

@@ -0,0 +1,16 @@
+from typing import NamedTuple
+
+
+class Device(NamedTuple):
+    available: bool
+    name: str | None
+    reason: str | None
+
+
+def get_device() -> Device:
+    import mojo.importer  # noqa: F401
+
+    from .mojo_module import _get_device
+
+    available, name, reason = _get_device()
+    return Device(available, name or None, reason or None)

simpok/mojo_module.mojo

@@ -0,0 +1,71 @@
+from std.python import PythonObject
+from std.python import Python
+from std.python.bindings import PythonModuleBuilder
+from _core_mojo import get_device, run_tdgl, run_chc
+from std.os import abort
+
+
+@export
+def PyInit_mojo_module() abi("C") -> PythonObject:
+    try:
+        var m = PythonModuleBuilder("mojo_module")
+        m.def_function[_get_device](
+            "_get_device", docstring="Probe the default accelerator"
+        )
+        m.def_function[_tdgl_run](
+            "_tdgl_run", docstring="Evolve a 2d TDGL field in place"
+        )
+        m.def_function[_chc_run](
+            "_chc_run", docstring="Evolve a 2d CHC field in place"
+        )
+        return m.finalize()
+    except e:
+        abort(String("error creating Python Mojo module: ", e))
+
+
+def _get_device() raises -> PythonObject:
+    var available, name, reason = get_device()
+    return Python.tuple(
+        PythonObject(available), PythonObject(name), PythonObject(reason)
+    )
+
+
+def _tdgl_run(
+    field: PythonObject, snaps: PythonObject, params: PythonObject
+) raises -> PythonObject:
+    var backend = run_tdgl(
+        Int(py=field.ctypes.data),
+        Int(py=snaps.ctypes.data),
+        Int(py=params[0]),
+        Int(py=params[1]),
+        Int(py=params[2]),
+        Float64(py=params[3]),
+        Float64(py=params[4]),
+        Float64(py=params[5]),
+        Float64(py=params[6]),
+        Int(py=params[7]),
+        Int(py=params[8]),
+        Bool(py=params[9]),
+        Int(py=params[10]),
+    )
+    return PythonObject(backend)
+
+
+def _chc_run(
+    field: PythonObject, snaps: PythonObject, params: PythonObject
+) raises -> PythonObject:
+    var backend = run_chc(
+        Int(py=field.ctypes.data),
+        Int(py=snaps.ctypes.data),
+        Int(py=params[0]),
+        Int(py=params[1]),
+        Int(py=params[2]),
+        Float64(py=params[3]),
+        Float64(py=params[4]),
+        Float64(py=params[5]),
+        Int(py=params[6]),
+        Int(py=params[7]),
+        Bool(py=params[8]),
+        Int(py=params[9]),
+    )
+    return PythonObject(backend)

simpok/tdgl.py

@@ -0,0 +1,128 @@
+import time
+import numpy as np
+from ._result import Result, device_code, make_meta
+
+class TDGL:
+    def __init__(self, n=256, dx=1.0, dt=0.1, h=0.0, eps=0.0,
+                 dtype=np.float64, device="auto"):
+        dtype = np.dtype(dtype)
+        self._device_code = device_code(device)
+        self.device = device
+        if dtype not in (np.dtype(np.float32), np.dtype(np.float64)):
+            raise ValueError(
+                f"dtype must be float32 or float64, got {dtype.name}"
+            )
+        if int(n) != n or n < 3:
+            raise ValueError(f"n must be an integer >= 3, got {n!r}")
+        if dx <= 0.0:
+            raise ValueError(f"dx must be positive, got {dx!r}")
+        if dt <= 0.0:
+            raise ValueError(f"dt must be positive, got {dt!r}")
+        if eps < 0.0:
+            raise ValueError(f"eps must be non-negative, got {eps!r}")
+
+        limit = 0.25 * dx * dx
+        if dt > limit:
+            raise ValueError(
+                f"dt={dt} exceeds the explicit-Euler stability limit "
+                f"dx^2/4={limit} for the 2-d 5-point Laplacian"
+            )
+
+        self.n = int(n)
+        self.dx = float(dx)
+        self.dt = float(dt)
+        self.h = float(h)
+        self.eps = float(eps)
+        self.dtype = dtype
+
+        self.psi = None
+        self.seed = 0
+        self.amplitude = 0.0
+        self.step = 0
+        self.backend = None
+
+    def ic(self, seed=0, amplitude=0.01):
+        if amplitude <= 0.0:
+            raise ValueError(f"amplitude must be positive, got {amplitude!r}")
+
+        rng = np.random.default_rng(seed)
+        self.psi = rng.uniform(
+            -amplitude, amplitude, size=(self.n, self.n)
+        ).astype(self.dtype)
+        self.seed = int(seed)
+        self.amplitude = float(amplitude)
+        self.step = 0
+        return self
+
+    @property
+    def t(self):
+        return self.step * self.dt
+
+    def run(self, steps, nevery):
+        if self.psi is None:
+            raise RuntimeError("call ic() before run()")
+        if np.shape(self.psi) != (self.n, self.n):
+            raise ValueError(
+                f"psi has shape {np.shape(self.psi)}, expected "
+                f"{(self.n, self.n)}"
+            )
+        if int(steps) != steps or steps < 1:
+            raise ValueError(f"steps must be a positive integer, got {steps!r}")
+        if int(nevery) != nevery or nevery < 1:
+            raise ValueError(
+                f"nevery must be a positive integer, got {nevery!r}"
+            )
+        if nevery > steps:
+            raise ValueError(f"nevery={nevery} exceeds steps={steps}")
+
+        steps = int(steps)
+        nevery = int(nevery)
+        nsnap = steps // nevery
+        step_start = self.step
+
+        import mojo.importer  # noqa: F401
+
+        from .mojo_module import _tdgl_run
+
+        field = np.ascontiguousarray(self.psi, dtype=self.dtype)
+        snaps = np.empty((nsnap, self.n, self.n), dtype=self.dtype)
+        params = (
+            self.n,
+            steps,
+            nevery,
+            self.dt,
+            self.dx,
+            self.h,
+            self.eps,
+            self.seed,
+            self.step,
+            self.dtype == np.dtype(np.float32),
+            self._device_code,
+        )
+
+        t0 = time.perf_counter()
+        self.backend = _tdgl_run(field, snaps, params)
+        elapsed = time.perf_counter() - t0
+
+        self.psi = field
+        self.step += steps
+
+        meta = make_meta(
+            "tdgl",
+            n=self.n,
+            dx=self.dx,
+            dt=self.dt,
+            h=self.h,
+            eps=self.eps,
+            dtype=self.dtype,
+            seed=self.seed,
+            amplitude=self.amplitude,
+            steps=steps,
+            nevery=nevery,
+            step_start=step_start,
+            step_end=self.step,
+            backend=self.backend,
+            device=self.device,
+            elapsed=elapsed,
+        )
+        return Result(snaps, meta)

simpok-0.1.0.dist-info/METADATA

@@ -0,0 +1,173 @@
+Metadata-Version: 2.5
+Name: simpok
+Version: 0.1.0
+Summary: High-level Python API for phase-ordering kinetics, with the computation in Mojo
+Project-URL: Homepage, https://github.com/ivijayyadav/simpok
+Project-URL: Repository, https://github.com/ivijayyadav/simpok
+Project-URL: Issues, https://github.com/ivijayyadav/simpok/issues
+Author-email: vijay <vijpiml@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: cahn-hilliard,ginzburg-landau,gpu,mojo,phase-field,phase-ordering,spinodal-decomposition
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Requires-Dist: max<27,>=26.5
+Requires-Dist: mojo<2,>=1.0
+Requires-Dist: numpy>=1.24
+Provides-Extra: examples
+Requires-Dist: matplotlib>=3.8; extra == 'examples'
+Description-Content-Type: text/markdown
+
+# simpok
+
+Phase-ordering kinetics in Python, with the computation in [Mojo](https://www.modular.com/mojo).
+
+You write ordinary Python; the solvers run on your GPU if you have one, and on the CPU
+otherwise, from the same code. The intent is to keep the modelling in a high-level API and push
+the per-site arithmetic down to Mojo.
+
+> **Status: alpha.** Two solvers, 2-d only, 5-point Laplacian, periodic boundaries. The API may
+> still change.
+
+## Install
+
+```bash
+pip install simpok
+```
+
+Python 3.10+. The Mojo toolchain arrives as a dependency — there is nothing else to install, and
+no compiler to set up by hand.
+
+**The first `import simpok` takes about 20 seconds.** It is compiling the Mojo sources for your
+machine; the result is cached and every later import is instant. It recompiles only when the
+package is upgraded. This is deliberate rather than a packaging shortcut: whether an accelerator
+is targeted is decided at Mojo compile time, so building on your machine is what lets one
+universal wheel use whatever hardware you actually have.
+
+## Quick start
+
+```python
+from simpok import TDGL
+
+sim = TDGL().ic(seed=0)
+snaps, meta = sim.run(steps=90000, nevery=1000)
+
+print(snaps.shape)          # (90, 256, 256)
+print(meta["backend"])      # 'accelerator' or 'cpu'
+print(meta["times"][-1])    # 9000.0
+```
+
+`run` returns a `Result` — a named tuple of `snaps` (a `(nsnap, n, n)` NumPy array) and `meta`
+(a dict of every parameter used, plus `times`, `backend`, `device` and `elapsed`).
+
+Conserved dynamics works the same way:
+
+```python
+from simpok import CHC
+
+snaps, meta = CHC().ic(seed=0, psi0=-0.4).run(steps=50000, nevery=500)
+```
+
+Check what you're running on:
+
+```python
+from simpok import get_device
+print(get_device())   # Device(available=True, name='NVIDIA RTX A5000', reason=None)
+```
+
+## The models
+
+**`TDGL`** — nonconserved scalar order parameter (Model A). Domain coarsening in a quenched
+ferromagnet; the Allen–Cahn growth law `L(t) ~ t^(1/2)`.
+
+```
+∂ψ/∂t = ψ − ψ³ + h + ∇²ψ + θ
+```
+
+**`CHC`** — conserved scalar order parameter (Model B). Spinodal decomposition in a binary
+mixture; the Lifshitz–Slyozov growth law `L(t) ~ t^(1/3)`. The mean of ψ is conserved exactly,
+so `psi0` sets the composition — `0.0` gives the bicontinuous critical quench, `-0.4` gives
+minority droplets.
+
+```
+∂ψ/∂t = −∇²(ψ − ψ³ + ∇²ψ) + ∇·θ
+```
+
+Thermal noise is off by default (`eps=0`) — it is asymptotically irrelevant to
+the growth laws. Set `eps > 0` to switch it on; for `CHC` it is applied as a bond-centred current
+so that conservation stays exact to round-off.
+
+## API
+
+```python
+TDGL(n=256, dx=1.0, dt=0.1,  h=0.0, eps=0.0, dtype=np.float64, device="auto")
+CHC (n=256, dx=1.0, dt=0.01,        eps=0.0, dtype=np.float64, device="auto")
+```
+
+| Method | |
+|---|---|
+| `.ic(seed=0, amplitude=0.01)` | random initial condition; `CHC` also takes `psi0=0.0`. Returns `self`, so it chains. |
+| `.run(steps, nevery)` | evolve `steps` steps, saving every `nevery`. Returns `Result(snaps, meta)`. |
+| `.t` | current simulation time |
+| `.psi` | current field, carried across calls — successive `run` calls continue the trajectory |
+
+`device` is `"auto"` (default), `"accelerator"`, or `"cpu"`. `"accelerator"` raises if none is
+usable rather than silently falling back. `dtype` is `float64` (default) or `float32`.
+
+Timesteps are checked against the explicit-Euler stability limit at construction — `dt <= dx²/4`
+for `TDGL`, and the much tighter fourth-order bound for `CHC`, which is why its default `dt` is
+ten times smaller.
+
+## Hardware notes
+
+- **NVIDIA** — both dtypes work.
+- **Apple Silicon** — Metal has no float64 at all, so use `dtype=np.float32` to run on the GPU.
+  A float64 run falls back to the CPU automatically; asking for `device="accelerator"` with
+  float64 raises with an explanation.
+- **No GPU** — everything runs on the CPU with identical results. Deterministic (`eps=0`) runs
+  are bit-identical between CPU and accelerator.
+
+On float32, `CHC` is several times faster than float64 on consumer NVIDIA cards, whose
+double-precision throughput is heavily reduced; the domain length scale agrees with float64 to
+better than 0.01%. `TDGL` at small grids is limited by kernel-launch overhead rather than
+arithmetic, so larger lattices use the GPU far more efficiently than small ones.
+
+## Correctness
+
+Both solvers are checked against analytic results, not just for plausibility:
+
+- equilibrium interface `tanh(z/√2)`, second-order convergent in `dx`
+- `TDGL`: droplet collapse `dR²/dt = −2(d−1)`; the `t^(1/2)` growth law
+- `CHC`: the Cahn dispersion relation `σ(q) = q − q²` reproduced to 1 part in 10¹⁰; the mean
+  conserved to 1 part in 10¹⁷; the `t^(1/3)` growth law
+- conserved noise verified against the discrete fluctuation–dissipation relation
+- seed reproducibility, resumability, and CPU/accelerator agreement
+
+## Examples
+
+`examples/` contains runnable scripts that produce snapshot figures:
+
+```bash
+python -m examples.tdgl_quickstart   # writes tdgl.png
+python -m examples.chc_quickstart    # writes chc.png
+```
+
+They need matplotlib: `pip install simpok[examples]`.
+
+## Reference
+
+Sanjay Puri, "Kinetics of Phase Transitions", Ch. 1 in *Kinetics of Phase Transitions*,
+S. Puri and V. Wadhawan (eds.), CRC Press (2009).
+
+## License
+
+MIT — see [LICENSE](LICENSE).

simpok-0.1.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+simpok/__init__.py,sha256=qAusnQnv2qQUBzwP3Y_Hdi0OMHiIB8aj55Qg0ih1wuI,172
+simpok/_result.py,sha256=kauuiZy77ug4z21S5BA8PFZEE8W0jCsMk2CyeO4ee1w,1419
+simpok/chc.py,sha256=4rrpw8ODPvQKXmjHdHEImkROoAxh9kWPYrxSmNgxBps,4069
+simpok/device.py,sha256=O2rfjc0QCTyN8Tfc1kjqmQGsKapqv88hz9ou0_SgyIQ,337
+simpok/mojo_module.mojo,sha256=8l4WqOmYdEzVSw_pm0BTkuBdSbY_jtJZt6S3vgWSNew,2050
+simpok/tdgl.py,sha256=BaJh5q3tKe0oQeRMNOXbuMqxOuiiN87b8NOduxZpX18,3937
+simpok/_core_mojo/__init__.mojo,sha256=fa4nrlLtv-mIAF0fJlLI8rggolZWONAFD0VcXZoPsX8,85
+simpok/_core_mojo/_chc.mojo,sha256=6OiZbsTtpD40TxuW8bsPjkUZHdTZH1rejXY4MRi9UuM,10286
+simpok/_core_mojo/_tdgl.mojo,sha256=7AJQlT-I4SKnvg5Ffn-WJ2COr6ZdEhzs1zn0VOUVD8M,8364
+simpok/_core_mojo/_utils.mojo,sha256=Yejb5W7UpBDq79SAdGnYtWoCUpMcUupKsvCou8d7KoU,1582
+simpok-0.1.0.dist-info/METADATA,sha256=BxS5WLovjFjSa0prVEJJdqF-NLuHVvOTPviW27ndl-k,6620
+simpok-0.1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+simpok-0.1.0.dist-info/licenses/LICENSE,sha256=XunFJgLLY9giZlL2BsiFAlkkhEOA2BFwkvYpuo1k9GU,1068
+simpok-0.1.0.dist-info/RECORD,,

simpok-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

simpok-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vijay Yadav
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.