SYNTOLOGY HomeExplorerAtlasCodeMethodologyAboutDevelopersFeedPricing
Paper · 2211.12285 · 2022

Exact-NeRF: An Exploration of a Precise Volumetric Parameterization for Neural Radiance Fields

arXiv · PDF · Open in the Atlas

Code that ran

23 of 24 samples (functions and classes) lifted from this paper's linked repositories executed on a synthesized input in Syntology's jail (0 of them constructed an object rather than computing a result; 2 honoured the contract we drafted, 3 violated it and 13 have no contract verdict; 5 failures of our instrument; 1 no recorded run), measured 2026-11-22; repository links from the Papers with Code archive attributed under CC BY-SA, no affiliation; bodies inline only under a permissive licence as GitHub detects it. Not a reproduction of the paper's results.

"Ran" means the function executed on a synthesized input and returned a value. It is not a reproduction of the paper's results. This record, dated, as JSON: /api/ran/2211.12285.json · badge: /api/ran/2211.12285.svg

Each repository's role is a label: a classifier's output recorded on the link, or, where no role is recorded, what the Papers with Code archive marked. The line under it names its basis. Neither says who wrote the code.

RepositoryRoleRan
kostadinovshalon/exact-nerf canonical (classifier label)
classifier basis not recorded on the link
23 ran · 1 no recorded run
FunctionStatusWhere it lives
bilinear_demosaic Ran
ran; our contract draft was wrong, not the code
kostadinovshalon/exact-nerf/internal/raw_utils.py
code served (permissive licence) · get_code("5ffdd10665900fb7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned ndarray, ndim 3, dtype family float, shape (4, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np
import jax.numpy as jnp
import types

# Create a small Bayer mosaic pattern image
# Bayer pattern is [H, W] with 2x2 repeating pattern:
# R G
# G B
# We'll create a 4x4 image to have enough data for the demosaicing operations
height, width = 4, 4
bayer_data = np.array([
    [100, 150, 110, 160],
    [120, 80,  130, 90],
    [105, 155, 115, 165],
    [125, 85,  135, 95]
], dtype=np.float32)

# Use numpy as the xnp module
xnp = np

ARGS = {
    "bayer": bayer_data,
    "xnp": xnp,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (4, 4, 3) — shape (4, 4, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_sq_dist Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/geopoly.py
code served (permissive licence) · get_code("7d889d94a6a2c807")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (3, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create two matrices with different shapes for unambiguous dimension testing
# mat0 will be 5x3 (5 features, 3 samples)
# mat1 will be 5x4 (5 features, 4 samples)
mat0 = np.random.randn(5, 3).astype(np.float32)
mat1 = np.random.randn(5, 4).astype(np.float32)

ARGS = {
    "mat0": mat0,
    "mat1": mat1,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (3, 4) — shape (3, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_tesselation_weights Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/geopoly.py
code served (permissive licence) · get_code("0d09727cd42c0bff")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (6, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

ARGS = {
    'v': 2
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (6, 3) — shape (6, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
compute_weighted_mae Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/ref_utils.py
code served (permissive licence) · get_code("c2c08f46f8721182")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# Create small unit-length normal vectors (batch_size=2, dims=3)
np.random.seed(0)

# Generate random normals and normalize to unit length
normals_data = np.random.randn(2, 3).astype(np.float32)
normals_data = normals_data / np.linalg.norm(normals_data, axis=1, keepdims=True)

normals_gt_data = np.random.randn(2, 3).astype(np.float32)
normals_gt_data = normals_gt_data / np.linalg.norm(normals_gt_data, axis=1, keepdims=True)

# Create weights (batch_size=2)
weights_data = np.array([0.5, 1.5], dtype=np.float32)

# Convert to JAX arrays
weights = jnp.array(weights_data)
normals = jnp.array(normals_data)
normals_gt = jnp.array(normals_gt_data)

ARGS = {
    "weights": weights,
    "normals": normals,
    "normals_gt": normals_gt,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
conical_frustum_to_gaussian Ran
ran; the contract check could not run (RAISES, DEP_MISSING or TIMEOUT)
kostadinovshalon/exact-nerf/internal/render.py
code served (permissive licence) · get_code("52da3923171d06b7")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 3, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp

# Construct valid arguments for conical_frustum_to_gaussian
d = jnp.array([1.0, 0.5, 0.2])  # 3-vector, the axis of the cone
t0 = 0.5  # float, starting distance
t1 = 2.5  # float, ending distance
base_radius = 0.1  # float, radius scale
diag = True  # boolean, diagonal covariance
stable = True  # boolean, stable computation

ARGS = {
    "d": d,
    "t0": t0,
    "t1": t1,
    "base_radius": base_radius,
    "diag": diag,
    "stable": stable,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 3, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
contract Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/coord.py
code served (permissive licence) · get_code("b862356a360b27e8")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 3, dtype family float, shape (2, 2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp

# Create a small test input tensor
# The function expects x to be an array-like object with shape (..., D)
# where the last dimension represents points/vectors
x = jnp.array([
    [[1.0, 0.5, 0.3, 0.2],
     [0.1, 0.2, 0.3, 0.4]],
    [[2.0, 1.5, 1.0, 0.5],
     [0.05, 0.15, 0.25, 0.35]]
], dtype=jnp.float64)

ARGS = {
    "x": x,
    "xnp": jnp
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 3, dtype family float, shape (2, 2, 4) — shape (2, 2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
convert_to_ndc Ran
ran; our contract draft was wrong, not the code
kostadinovshalon/exact-nerf/internal/camera_utils.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from shreyesss/hdrsplat, is pointer only (licence: NONE) · get_code("f4dbe624cddbd165")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from shreyesss/hdrsplat, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

inv_contract Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/coord.py
code served (permissive licence) · get_code("47957f74e1e36dc0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# Create a small test input tensor for z
# The function expects z to be an array where we can compute sum along axis=-1
# Shape: (batch_size, feature_dim) = (2, 4)
z_value = jnp.array([
    [0.1, 0.2, 0.3, 0.4],
    [0.5, 0.6, 0.7, 0.8]
], dtype=jnp.float32)

ARGS = {
    "z": z_value
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
l2_normalize Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/ref_utils.py
code served (permissive licence) · get_code("e8304fe593a5daa6")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 2, dtype family float, shape (2, 4) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp

# Create a simple input array for l2_normalize
# The function normalizes along the last axis, so we create a small array
x = jnp.array([
    [1.0, 2.0, 3.0, 4.0],
    [5.0, 6.0, 7.0, 8.0]
], dtype=jnp.float32)

# eps parameter uses default from jnp.finfo(jnp.float32).eps
eps = jnp.finfo(jnp.float32).eps

ARGS = {
    "x": x,
    "eps": eps
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 4) — shape (2, 4) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
lift_gaussian Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/render.py
code served (permissive licence) · get_code("b08a5fcef9a0e68a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple, ndim 4, dtype family float; no output shape is stated. The image it ran in was not recorded. If your copy returns the same type and ndim on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# Set seed for reproducibility
np.random.seed(0)

# Create valid arguments for lift_gaussian
# d: direction vector, shape (..., 3) - representing 3D directions
# t_mean: mean along ray, shape (...)
# t_var: variance along ray, shape (...)
# r_var: radial variance, shape (...)
# diag: boolean flag for diagonal covariance computation

batch_size = 2
spatial_dim = 3

# d: direction vectors with shape (batch_size, spatial_dim)
d = jnp.array(np.random.randn(batch_size, spatial_dim), dtype=jnp.float32)
d = d / jnp.linalg.norm(d, axis=-1, keepdims=True)  # normalize

# t_mean: mean values along ray with shape (batch_size,)
t_mean = jnp.array(np.random.randn(batch_size), dtype=jnp.float32)

# t_var: variance along ray with shape (batch_size,)
t_var = jnp.array(np.abs(np.random.randn(batch_size)), dtype=jnp.float32)

# r_var: radial variance with shape (batch_size,)
r_var = jnp.array(np.abs(np.random.randn(batch_size)), dtype=jnp.float32)

# diag: boolean flag
diag = True

ARGS = {
    "d": d,
    "t_mean": t_mean,
    "t_var": t_var,
    "r_var": r_var,
    "diag": diag,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple, ndim 4, dtype family float — a tuple output has no array shape of its own; none is stated
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
matmul Ran
ran, honoured the contract we drafted
kostadinovshalon/exact-nerf/internal/math.py
code served (permissive licence) · get_code("0f92b856a4c7ffa0")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 2, dtype family float, shape (2, 2) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp

# Create two small JAX arrays for matrix multiplication
a = jnp.array([[1.0, 2.0, 3.0],
               [4.0, 5.0, 6.0]], dtype=jnp.float32)

b = jnp.array([[1.0, 2.0],
               [3.0, 4.0],
               [5.0, 6.0]], dtype=jnp.float32)

ARGS = {
    "a": a,
    "b": b
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 2, dtype family float, shape (2, 2) — shape (2, 2) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
mse_to_psnr Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/image.py
code served (permissive licence) · get_code("653ab4e689447ac1")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# The function mse_to_psnr takes a single parameter 'mse'
# It performs arithmetic operations on it (jnp.log, division, multiplication)
# So mse should be a JAX array or numpy array with numeric values

# Create a small MSE value (mean squared error should be positive and typically small)
mse_value = jnp.array(0.01)

ARGS = {
    "mse": mse_value
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
pad_poses Ran
ran, violated the contract we drafted
kostadinovshalon/exact-nerf/internal/camera_utils.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from shreyesss/hdrsplat, is pointer only (licence: NONE) · get_code("a53323fc4f4e3bec")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from shreyesss/hdrsplat, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

pixels_to_bayer_mask Ran
ran, honoured the contract we drafted
kostadinovshalon/exact-nerf/internal/raw_utils.py
code served (permissive licence) · get_code("5b3256eff4159b19")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1) and returned ndarray, ndim 3, dtype family float, shape (2, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create small integer arrays for pixel coordinates
pix_x = np.array([[0, 1, 2, 3], [0, 1, 2, 3]], dtype=np.int32)
pix_y = np.array([[0, 0, 0, 0], [1, 1, 1, 1]], dtype=np.int32)

ARGS = {
    "pix_x": pix_x,
    "pix_y": pix_y,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 3, dtype family float, shape (2, 4, 3) — shape (2, 4, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
psnr_to_mse Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/image.py
code served (permissive licence) · get_code("49c09d68ba665662")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 0, dtype family float, shape () as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp

# The function takes a single parameter: psnr
# It performs mathematical operations on it (exp, log, multiplication)
# So we need to pass a scalar or array that can be used with JAX operations

# Create a simple scalar PSNR value
psnr_value = jnp.array(20.0)

ARGS = {
    "psnr": psnr_value
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 0, dtype family float, shape () — shape () as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
random_split Ran
ran; our contract draft was wrong, not the code
kostadinovshalon/exact-nerf/internal/models.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from shreyesss/hdrsplat, is pointer only (licence: NONE) · get_code("174280feba78ca68")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from shreyesss/hdrsplat, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

reflect Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/ref_utils.py
code served (permissive licence) · get_code("4f16f24f7c41ab8c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 3, dtype family float, shape (2, 4, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import numpy as np

# Create small test data for viewdirs and normals
# Shape: [batch=2, spatial=4, 3]
batch_size = 2
spatial_size = 4
vec_dim = 3

# Create view directions - arbitrary 3D vectors
viewdirs = jnp.array(np.random.randn(batch_size, spatial_size, vec_dim), dtype=jnp.float32)

# Create normal directions - unit vectors
normals_raw = np.random.randn(batch_size, spatial_size, vec_dim)
normals = normals_raw / np.linalg.norm(normals_raw, axis=-1, keepdims=True)
normals = jnp.array(normals, dtype=jnp.float32)

ARGS = {
    "viewdirs": viewdirs,
    "normals": normals,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax, numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 3, dtype family float, shape (2, 4, 3) — shape (2, 4, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
safe_cos Ran
ran, violated the contract we drafted
kostadinovshalon/exact-nerf/internal/math.py
code served (permissive licence) · get_code("7033f6fda964538a")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp

# Create a small test input for safe_cos
# The function takes x as input and applies jnp.cos after modding by t
x = jnp.array([0.5, 1.5, 2.5, 3.5])

ARGS = {
    "x": x,
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
safe_trig_helper Ran
ran; our contract draft was wrong, not the code
kostadinovshalon/exact-nerf/internal/math.py
code served (permissive licence) · get_code("762b96fa7015de47")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ArrayImpl, ndim 1, dtype family float, shape (4,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax.numpy as jnp
import jax

# Create valid arguments for safe_trig_helper
x = jnp.array([0.5, 1.0, 100.0, 500.0])

# Use jax.numpy.sin as the function argument
fn = jnp.sin

# Use default t value (100 * jnp.pi)
t = 100 * jnp.pi

ARGS = {
    "x": x,
    "fn": fn,
    "t": t
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ArrayImpl, ndim 1, dtype family float, shape (4,) — shape (4,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
ssim_to_dssim Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/image.py
code served (permissive licence) · get_code("4d380547a7c009a9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned Tensor, ndim 1, dtype family float, shape (2,) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import torch
import numpy as np

torch.manual_seed(0)

# ssim_to_dssim takes a single parameter: ssim
# The function computes (1 - ssim) / 2
# ssim should be a numeric value or tensor

# Create a small tensor representing SSIM values
# SSIM typically ranges from -1 to 1, with 1 being perfect similarity
ssim_value = torch.tensor([0.85, 0.92], dtype=torch.float32)

ARGS = {
    "ssim": ssim_value
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy, torch — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type Tensor, ndim 1, dtype family float, shape (2,) — shape (2,) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
tesselate_geodesic Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/geopoly.py
code served (permissive licence) · get_code("20ba3d607e5d7fb9")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned ndarray, ndim 2, dtype family float, shape (10, 3) as a later run recorded it. The image it ran in was not recorded. If your copy returns the same type, ndim and shape on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import numpy as np

# Create base vertices for a small geodesic polyhedron (e.g., tetrahedron)
# We need at least 4 vertices in 3D space
base_verts = np.array([
    [1.0, 1.0, 1.0],
    [1.0, -1.0, -1.0],
    [-1.0, 1.0, -1.0],
    [-1.0, -1.0, 1.0]
], dtype=np.float64)

# Normalize vertices to lie on unit sphere
base_verts = base_verts / np.linalg.norm(base_verts, axis=1, keepdims=True)

# Create faces - each face is a triangle (3 vertex indices)
# For a tetrahedron, we have 4 faces
base_faces = np.array([
    [0, 1, 2],
    [0, 1, 3],
    [0, 2, 3],
    [1, 2, 3]
], dtype=np.int32)

# Tesselation factor (must be integer >= 1)
v = 2

# Epsilon for determining duplicate vertices
eps = 0.0001

ARGS = {
    'base_verts': base_verts,
    'base_faces': base_faces,
    'v': v,
    'eps': eps
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
numpy — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type ndarray, ndim 2, dtype family float, shape (10, 3) — shape (10, 3) as a later run recorded it
dtype family
int means an integer dtype; float means any other dtype the instrument saw, bool and complex included (fixture_check.py records only these two families)
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
track_linearize Ran
ran on a synthesized input
kostadinovshalon/exact-nerf/internal/coord.py
code served (permissive licence) · get_code("e3cb11e61e30323c")
How it ran

Ran in Syntology's sandbox on this synthesized input (drafted by a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API) and returned tuple. The image it ran in was not recorded. If your copy returns the same type on these inputs, it matched what we observed; nothing here checks that. It does NOT mean the output is correct: nothing has compared it to the paper.

import jax
import jax.numpy as jnp

# Define a simple function to linearize
def simple_fn(x):
    """A simple nonlinear function for testing"""
    return jnp.sin(x) + 0.5 * x**2

# Create small test tensors
# mean: shape (2, 4) - batch of 2, dimension 4
mean = jnp.array([
    [0.1, 0.2, 0.3, 0.4],
    [0.5, 0.6, 0.7, 0.8]
], dtype=jnp.float32)

# cov: shape (2, 4, 4) - batch of 2, covariance matrices of 4x4
# Create simple positive definite covariance matrices
eye_4 = jnp.eye(4, dtype=jnp.float32)
cov = jnp.array([
    0.1 * eye_4,
    0.2 * eye_4
], dtype=jnp.float32)

ARGS = {
    "fn": simple_fn,
    "mean": mean,
    "cov": cov
}
Setup block drafted by
a language model, Claude Haiku 4.5, prompt python_fixture_v1, through the batch API
Imports
jax — import names as written, not package names to install; a name the repository itself provides is not a package
Returned
type tuple — a tuple output has no array shape of its own; none is stated
Environment
image not recorded; re-verify against syntology-harvest-sandbox:v5-deps; not recorded for this sample: the harness installs a cuda-to-cpu shim (cuda_shim.py) before every sample and no run records whether a sample needed it; seed: none by the harness; any seed is in the setup block
unpad_poses Ran
ran, violated the contract we drafted
kostadinovshalon/exact-nerf/internal/camera_utils.py
pointer only (licence: Apache-2.0); the stored copy get_code serves, from shreyesss/hdrsplat, is pointer only (licence: NONE) · get_code("02a28751c0dd380b")
How it ran

The body of this sample is withheld: this paper's link allows the body inline (Apache-2.0), but get_code serves the stored copy, first harvested from shreyesss/hdrsplat, and GitHub detected no licence in that repository when it was checked. The setup block that called it is withheld with it, because it is written against that body. source_path and origin say where the code lives, to read under the repository's own terms. A run is recorded.

cylinder_to_gaussian Not yet run
unverified (harvested, no recorded run)
kostadinovshalon/exact-nerf/internal/render.py
code served (permissive licence) · get_code("7f7427c5ca12b95c")
How it ran

no invocation recorded.

Also present in other papers' code

Of 24 samples lifted from this paper's linked repositories, 24 carry a function identity and 0 do not. Of the 24 distinct functions with an identity, 23 are also present in other papers whose code we hold (7 with at least one paper dated earlier, 0 the same month, 23 later) and 1 are only here among the 52,977 papers whose code Syntology holds (as of 2026-09-26).

Only here means: among the 52,977 papers whose code Syntology holds (51,887 with lifted samples, 1,090 through their assemblies only), as of 2026-09-26, no other paper's lifted samples or current assembly bricks contain an identical function body after normalisation.

FunctionAlso present inEarliest-datedOthers named
matmul 5 other papers
2 dated earlier, 3 later
2103.13415 (2021-03)
Mip-NeRF: A Multiscale Representation for Anti-Aliasing Neural Radiance Fields
2112.01983 (2021-12)
CoNeRF: Controllable Neural Radiance Fields
2302.08788 (2023-02)
MixNeRF: Modeling a Ray with Mixture Density for Novel View Synthesis from Sparse Inputs
and 2 more not named here
safe_cos 4 other papers
1 dated earlier, 3 later
2103.13415 (2021-03)
Mip-NeRF: A Multiscale Representation for Anti-Aliasing Neural Radiance Fields
2302.08788 (2023-02)
MixNeRF: Modeling a Ray with Mixture Density for Novel View Synthesis from Sparse Inputs
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
and 1 more not named here
safe_trig_helper 4 other papers
1 dated earlier, 3 later
2103.13415 (2021-03)
Mip-NeRF: A Multiscale Representation for Anti-Aliasing Neural Radiance Fields
2302.08788 (2023-02)
MixNeRF: Modeling a Ray with Mixture Density for Novel View Synthesis from Sparse Inputs
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
and 1 more not named here
bilinear_demosaic 2 other papers
1 dated earlier, 1 later
2111.13679 (2021-11)
NeRF in the Dark: High Dynamic Range View Synthesis from Noisy Raw Images
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
cylinder_to_gaussian 2 other papers
1 dated earlier, 1 later
2103.13415 (2021-03)
Mip-NeRF: A Multiscale Representation for Anti-Aliasing Neural Radiance Fields
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
lift_gaussian 2 other papers
1 dated earlier, 1 later
2103.13415 (2021-03)
Mip-NeRF: A Multiscale Representation for Anti-Aliasing Neural Radiance Fields
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
pad_poses 2 other papers
2 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
2407.16503 (2024-07)
HDRSplat: Gaussian Splatting for High Dynamic Range 3D Scene Reconstruction from Raw Images
pixels_to_bayer_mask 2 other papers
1 dated earlier, 1 later
2111.13679 (2021-11)
NeRF in the Dark: High Dynamic Range View Synthesis from Noisy Raw Images
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
random_split 2 other papers
2 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
2407.16503 (2024-07)
HDRSplat: Gaussian Splatting for High Dynamic Range 3D Scene Reconstruction from Raw Images
unpad_poses 2 other papers
2 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
2407.16503 (2024-07)
HDRSplat: Gaussian Splatting for High Dynamic Range 3D Scene Reconstruction from Raw Images
compute_sq_dist 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
compute_tesselation_weights 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
compute_weighted_mae 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
conical_frustum_to_gaussian 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
convert_to_ndc 1 other paper
1 later
2407.16503 (2024-07)
HDRSplat: Gaussian Splatting for High Dynamic Range 3D Scene Reconstruction from Raw Images
inv_contract 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
l2_normalize 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
mse_to_psnr 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
psnr_to_mse 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media
reflect 1 other paper
1 later
2304.07743 (2023-04)
SeaThru-NeRF: Neural Radiance Fields in Scattering Media

Shown: the 20 functions present in the most other papers. 3 more shared functions are not listed here.

Presence, not direction: an identical function body in two papers' repositories does not say who wrote it, which came from which, or that either paper's method rests on it. Matching is exact after normalisation, so a renamed or edited function is not matched. Dates are when papers appeared, not when code was written. Only .py files the harvester lifted are covered; notebooks are not read. A new-style arXiv id YYMM.NNNN dates a paper to the month 20YY-MM; otherwise Paper.year dates it to the year; otherwise it is undated. Dates are when the paper appeared, not when the code was written. Read 2026-11-22.

Repositories linked to this paper

Some links come from the archived Papers with Code dataset (CC BY-SA 4.0): attribution and licence.

Abstract

Neural Radiance Fields (NeRF) have attracted significant attention due to their ability to synthesize novel scene views with great accuracy. However, inherent to their underlying formulation, the sampling of points along a ray with zero width may result in ambiguous representations that lead to further rendering artifacts such as aliasing in the final scene. To address this issue, the recent variant mip-NeRF proposes an Integrated Positional Encoding (IPE) based on a conical view frustum. Although this is expressed with an integral formulation, mip-NeRF instead approximates this integral as the expected value of a multivariate Gaussian distribution. This approximation is reliable for short frustums but degrades with highly elongated regions, which arises when dealing with distant scene objects under a larger depth of field. In this paper, we explore the use of an exact approach for calculating the IPE by using a pyramid-based integral formulation instead of an approximated conical-based one. We denote this formulation as Exact-NeRF and contribute the first approach to offer a precise analytical solution to the IPE within the NeRF domain. Our exploratory work illustrates that such an exact formulation Exact-NeRF matches the accuracy of mip-NeRF and furthermore provides a natural extension to more challenging scenarios without further modification, such as in the case of unbounded scenes. Our contribution aims to both address the hitherto unexplored issues of frustum approximation in earlier NeRF work and additionally provide insight into the potential future consideration of analytical solutions in future NeRF extensions.

For agents

The same record, over MCP at https://syntology.ai/mcp:

get_harvested_code_for_paper("2211.12285")
get_code_for_paper("2211.12285")
have("2211.12285")

The run record, dated, one paper per request, free:

curl https://syntology.ai/api/ran/2211.12285.json

A badge for a README (the split and the date, never a ratio):

[![Syntology run record](https://syntology.ai/api/ran/2211.12285.svg)](https://syntology.ai/paper/2211.12285)

Connect an agent — have() is free.